diff --git a/lib/puppet/pops.rb b/lib/puppet/pops.rb
index c075be013..63ccf78ef 100644
--- a/lib/puppet/pops.rb
+++ b/lib/puppet/pops.rb
@@ -1,97 +1,98 @@
 module Puppet
 
   module Pops
     require 'puppet/pops/patterns'
     require 'puppet/pops/utils'
 
     require 'puppet/pops/adaptable'
     require 'puppet/pops/adapters'
 
     require 'puppet/pops/visitable'
     require 'puppet/pops/visitor'
 
     require 'puppet/pops/containment'
 
     require 'puppet/pops/issues'
     require 'puppet/pops/label_provider'
     require 'puppet/pops/validation'
     require 'puppet/pops/issue_reporter'
 
     require 'puppet/pops/model/model'
 
     module Types
       require 'puppet/pops/types/types'
       require 'puppet/pops/types/type_calculator'
       require 'puppet/pops/types/type_factory'
       require 'puppet/pops/types/type_parser'
       require 'puppet/pops/types/class_loader'
       require 'puppet/pops/types/enumeration'
     end
 
     module Model
       require 'puppet/pops/model/tree_dumper'
       require 'puppet/pops/model/ast_transformer'
       require 'puppet/pops/model/ast_tree_dumper'
       require 'puppet/pops/model/factory'
       require 'puppet/pops/model/model_tree_dumper'
       require 'puppet/pops/model/model_label_provider'
     end
 
     module Binder
       module SchemeHandler
         # the handlers are auto loaded via bindings
       end
       module Producers
         require 'puppet/pops/binder/producers'
       end
 
       require 'puppet/pops/binder/binder'
       require 'puppet/pops/binder/bindings_model'
       require 'puppet/pops/binder/binder_issues'
       require 'puppet/pops/binder/bindings_checker'
       require 'puppet/pops/binder/bindings_factory'
       require 'puppet/pops/binder/bindings_label_provider'
       require 'puppet/pops/binder/bindings_validator_factory'
       require 'puppet/pops/binder/injector_entry'
       require 'puppet/pops/binder/key_factory'
       require 'puppet/pops/binder/injector'
       require 'puppet/pops/binder/bindings_composer'
       require 'puppet/pops/binder/bindings_model_dumper'
       require 'puppet/pops/binder/system_bindings'
       require 'puppet/pops/binder/bindings_loader'
       require 'puppet/pops/binder/lookup'
 
       module Config
         require 'puppet/pops/binder/config/binder_config'
         require 'puppet/pops/binder/config/binder_config_checker'
         require 'puppet/pops/binder/config/issues'
         require 'puppet/pops/binder/config/diagnostic_producer'
       end
     end
 
     module Parser
       require 'puppet/pops/parser/eparser'
       require 'puppet/pops/parser/parser_support'
       require 'puppet/pops/parser/locator'
       require 'puppet/pops/parser/locatable'
       require 'puppet/pops/parser/lexer'
       require 'puppet/pops/parser/lexer2'
       require 'puppet/pops/parser/evaluating_parser'
+      require 'puppet/pops/parser/epp_parser'
     end
 
     module Validation
       require 'puppet/pops/validation/checker3_1'
       require 'puppet/pops/validation/validator_factory_3_1'
       require 'puppet/pops/validation/checker4_0'
       require 'puppet/pops/validation/validator_factory_4_0'
     end
 
     module Evaluator
       require 'puppet/pops/evaluator/runtime3_support'
       require 'puppet/pops/evaluator/evaluator_impl'
     end
   end
 
   require 'puppet/parser/ast/pops_bridge'
   require 'puppet/bindings'
 end
diff --git a/lib/puppet/pops/evaluator/evaluator_impl.rb b/lib/puppet/pops/evaluator/evaluator_impl.rb
index 995b22dca..f5956de3f 100644
--- a/lib/puppet/pops/evaluator/evaluator_impl.rb
+++ b/lib/puppet/pops/evaluator/evaluator_impl.rb
@@ -1,991 +1,1001 @@
 require 'rgen/ecore/ecore'
 require 'puppet/pops/evaluator/compare_operator'
 require 'puppet/pops/evaluator/relationship_operator'
 require 'puppet/pops/evaluator/access_operator'
 require 'puppet/pops/evaluator/closure'
 require 'puppet/pops/evaluator/external_syntax_support'
 
 # This implementation of {Puppet::Pops::Evaluator} performs evaluation using the puppet 3.x runtime system
 # in a manner largely compatible with Puppet 3.x, but adds new features and introduces constraints.
 #
 # The evaluation uses _polymorphic dispatch_ which works by dispatching to the first found method named after
 # the class or one of its super-classes. The EvaluatorImpl itself mainly deals with evaluation (it currently
 # also handles assignment), and it uses a delegation pattern to more specialized handlers of some operators
 # that in turn use polymorphic dispatch; this to not clutter EvaluatorImpl with too much responsibility).
 #
 # Since a pattern is used, only the main entry points are fully documented. The parameters _o_ and _scope_ are
 # the same in all the polymorphic methods, (the type of the parameter _o_ is reflected in the method's name;
 # either the actual class, or one of its super classes). The _scope_ parameter is always the scope in which
 # the evaluation takes place. If nothing else is mentioned, the return is always the result of evaluation.
 #
 # See {Puppet::Pops::Visitable} and {Puppet::Pops::Visitor} for more information about
 # polymorphic calling.
 #
 class Puppet::Pops::Evaluator::EvaluatorImpl
   include Puppet::Pops::Utils
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
   include Puppet::Pops::Evaluator::Runtime3Support
   include Puppet::Pops::Evaluator::ExternalSyntaxSupport
 
   # This constant is not defined as Float::INFINITY in Ruby 1.8.7 (but is available in later version
   # Refactor when support is dropped for Ruby 1.8.7.
   #
   INFINITY = 1.0 / 0.0
 
   # Reference to Issues name space makes it easier to refer to issues
   # (Issues are shared with the validator).
   #
   Issues = Puppet::Pops::Issues
 
   def initialize
     @@eval_visitor   ||= Puppet::Pops::Visitor.new(self, "eval", 1, 1)
     @@lvalue_visitor   ||= Puppet::Pops::Visitor.new(self, "lvalue", 1, 1)
     @@assign_visitor   ||= Puppet::Pops::Visitor.new(self, "assign", 3, 3)
     @@string_visitor   ||= Puppet::Pops::Visitor.new(self, "string", 1, 1)
 
     @@type_calculator  ||= Puppet::Pops::Types::TypeCalculator.new()
     @@type_parser      ||= Puppet::Pops::Types::TypeParser.new()
 
     @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
     @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
 
     # Initialize the runtime module
     Puppet::Pops::Evaluator::Runtime3Support.instance_method(:initialize).bind(self).call()
   end
 
   # @api private
   def type_calculator
     @@type_calculator
   end
 
   # Polymorphic evaluate - calls eval_TYPE
   #
   # ## Polymorphic evaluate
   # Polymorphic evaluate calls a method on the format eval_TYPE where classname is the last
   # part of the class of the given _target_. A search is performed starting with the actual class, continuing
   # with each of the _target_ class's super classes until a matching method is found.
   #
   # # Description
   # Evaluates the given _target_ object in the given scope, optionally passing a block which will be
   # called with the result of the evaluation.
   #
   # @overload evaluate(target, scope, {|result| block})
   # @param target [Object] evaluation target - see methods on the pattern assign_TYPE for actual supported types.
   # @param scope [Object] the runtime specific scope class where evaluation should take place
   # @return [Object] the result of the evaluation
   #
   # @api
   #
   def evaluate(target, scope)
     begin
       @@eval_visitor.visit_this_1(self, target, scope)
     rescue StandardError => e
       if e.is_a? Puppet::ParseError
         raise e
       end
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
     end
   end
 
   # Polymorphic assign - calls assign_TYPE
   #
   # ## Polymorphic assign
   # Polymorphic assign calls a method on the format assign_TYPE where TYPE is the last
   # part of the class of the given _target_. A search is performed starting with the actual class, continuing
   # with each of the _target_ class's super classes until a matching method is found.
   #
   # # Description
   # Assigns the given _value_ to the given _target_. The additional argument _o_ is the instruction that
   # produced the target/value tuple and it is used to set the origin of the result.
   # @param target [Object] assignment target - see methods on the pattern assign_TYPE for actual supported types.
   # @param value [Object] the value to assign to `target`
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api
   #
   def assign(target, value, o, scope)
     @@assign_visitor.visit_this_3(self, target, value, o, scope)
   end
 
   def lvalue(o, scope)
     @@lvalue_visitor.visit_this_1(self, o, scope)
   end
 
   def string(o, scope)
     @@string_visitor.visit_this_1(self, o, scope)
   end
 
   # Call a closure - Can only be called with a Closure (for now), may be refactored later
   # to also handle other types of calls (function calls are also handled by CallNamedFunction and CallMethod, they
   # could create similar objects to Closure, wait until other types of defines are instantiated - they may behave
   # as special cases of calls - i.e. 'new')
   #
   # @raise ArgumentError, if there are to many or too few arguments
   # @raise ArgumentError, if given closure is not a Puppet::Pops::Evaluator::Closure
   #
   def call(closure, args, scope)
     raise ArgumentError, "Can only call a Lambda" unless closure.is_a?(Puppet::Pops::Evaluator::Closure)
     pblock = closure.model
     parameters = pblock.parameters || []
 
     raise ArgumentError, "Too many arguments: #{args.size} for #{parameters.size}" unless args.size <= parameters.size
 
     # associate values with parameters
     merged = parameters.zip(args)
     # calculate missing arguments
     missing = parameters.slice(args.size, parameters.size - args.size).select {|p| p.value.nil? }
     unless missing.empty?
       optional = parameters.count { |p| !p.value.nil? }
       raise ArgumentError, "Too few arguments; #{args.size} for #{optional > 0 ? ' min ' : ''}#{parameters.size - optional}"
     end
 
     evaluated = merged.collect do |m|
       # m can be one of
       # m = [Parameter{name => "name", value => nil], "given"]
       #   | [Parameter{name => "name", value => Expression}, "given"]
       #
       # "given" is always an optional entry. If a parameter was provided then
       # the entry will be in the array, otherwise the m array will be a
       # single element.a = []
       given_argument = m[1]
       argument_name = m[0].name
       default_expression = m[0].value
 
       value = if default_expression
         evaluate(default_expression, scope)
       else
         given_argument
       end
       [argument_name, value]
     end
 
     # Store the evaluated name => value associations in a new inner/local/ephemeral scope
     # (This is made complicated due to the fact that the implementation of scope is overloaded with
     # functionality and an inner ephemeral scope must be used (as opposed to just pushing a local scope
     # on a scope "stack").
 
     # Ensure variable exists with nil value if error occurs. 
     # Some ruby implementations does not like creating variable on return
     result = nil
     begin
       scope_memo = get_scope_nesting_level(scope)
       # change to create local scope_from - cannot give it file and line - that is the place of the call, not
       # "here"
       create_local_scope_from(Hash[evaluated], scope)
       result = evaluate(pblock.body, scope)
     ensure
       set_scope_nesting_level(scope, scope_memo)
     end
     result
   end
 
   protected
 
   def lvalue_VariableExpression(o, scope)
     # evaluate the name
     evaluate(o.expr, scope)
   end
 
   # Catches all illegal lvalues
   #
   def lvalue_Object(o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   # Assign value to named variable.
   # The '$' sign is never part of the name.
   # @example In Puppet DSL
   #   $name = value
   # @param name [String] name of variable without $
   # @param value [Object] value to assign to the variable
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   # @return [value<Object>]
   #
   def assign_String(name, value, o, scope)
     if name =~ /::/
       fail(Issues::CROSS_SCOPE_ASSIGNMENT, o.left_expr, {:name => name})
     end
     set_variable(name, value, o, scope)
     value
   end
 
   def assign_Numeric(n, value, o, scope)
     fail(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o.left_expr, {:varname => n.to_s})
   end
 
   # Catches all illegal assignment (e.g. 1 = 2, {'a'=>1} = 2, etc)
   #
   def assign_Object(name, value, o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   def eval_Factory(o, scope)
     evaluate(o.current, scope)
   end
 
   # Evaluates any object not evaluated to something else to itself.
   def eval_Object o, scope
     o
   end
 
   # Allows nil to be used as a Nop.
   # Evaluates to nil
   # TODO: What is the difference between literal undef, nil, and nop?
   #
   def eval_NilClass(o, scope)
     nil
   end
 
   # Evaluates Nop to nil.
   # TODO: or is this the same as :undef
   # TODO: is this even needed as a separate instruction when there is a literal undef?
   def eval_Nop(o, scope)
     nil
   end
 
   # Captures all LiteralValues not handled elsewhere.
   #
   def eval_LiteralValue(o, scope)
     o.value
   end
 
   def eval_LiteralDefault(o, scope)
     :default
   end
 
   def eval_LiteralUndef(o, scope)
     :undef # TODO: or just use nil for this?
   end
 
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
     @@type_parser.interpret(o)
   end
 
   def eval_NotExpression(o, scope)
     ! is_true?(evaluate(o.expr, scope))
   end
 
   def eval_UnaryMinusExpression(o, scope)
     - coerce_numeric(evaluate(o.expr, scope), o, scope)
   end
 
   # Abstract evaluation, returns array [left, right] with the evaluated result of left_expr and
   # right_expr
   # @return <Array<Object, Object>> array with result of evaluating left and right expressions
   #
   def eval_BinaryExpression o, scope
     [ evaluate(o.left_expr, scope), evaluate(o.right_expr, scope) ]
   end
 
   # Evaluates assignment with operators =, +=, -= and
   #
   # @example Puppet DSL
   #   $a = 1
   #   $a += 1
   #   $a -= 1
   #
   def eval_AssignmentExpression(o, scope)
     name = lvalue(o.left_expr, scope)
     value = evaluate(o.right_expr, scope)
 
     case o.operator
     when :'=' # regular assignment
       assign(name, value, o, scope)
 
     when :'+='
       # if value does not exist and strict is on, looking it up fails, else it is nil or :undef
       existing_value = get_variable_value(name, o, scope)
       begin
         if existing_value.nil? || existing_value == :undef
           assign(name, value, o, scope)
         else
           # Delegate to calculate function to deal with check of LHS, and perform ´+´ as arithmetic or concatenation the
           # same way as ArithmeticExpression performs `+`.
           assign(name, calculate(existing_value, value, :'+', o.left_expr, o.right_expr, scope), o, scope)
         end
       rescue ArgumentError => e
         fail(Issues::APPEND_FAILED, o, {:message => e.message})
       end
 
     when :'-='
       # If an attempt is made to delete values from something that does not exists, the value is :undef (it is guaranteed to not
       # include any values the user wants deleted anyway :-)
       #
       # if value does not exist and strict is on, looking it up fails, else it is nil or :undef
       existing_value = get_variable_value(name, o, scope)
       begin
       if existing_value.nil? || existing_value == :undef
         assign(name, :undef, o, scope)
       else
         # Delegate to delete function to deal with check of LHS, and perform deletion
         assign(name, delete(get_variable_value(name, o, scope), value), o, scope)
       end
       rescue ArgumentError => e
         fail(Issues::APPEND_FAILED, o, {:message => e.message}, e)
       end
     else
       fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
     end
     value
   end
 
   ARITHMETIC_OPERATORS = [:'+', :'-', :'*', :'/', :'%', :'<<', :'>>']
   COLLECTION_OPERATORS = [:'+', :'-', :'<<']
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def eval_ArithmeticExpression(o, scope)
     left, right = eval_BinaryExpression(o, scope)
     begin
       result = calculate(left, right, o.operator, o.left_expr, o.right_expr, scope)
     rescue ArgumentError => e
       fail(Issues::RUNTIME_ERROR, o, {:detail => e.message}, e)
     end
     result
   end
 
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def calculate(left, right, operator, left_o, right_o, scope)
     unless ARITHMETIC_OPERATORS.include?(operator)
       fail(Issues::UNSUPPORTED_OPERATOR, left_o.eContainer, {:operator => o.operator})
     end
 
     if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
       when :'+'
         concatenate(left, right)
       when :'-'
         delete(left, right)
       when :'<<'
         unless left.is_a?(Array)
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         left + [right]
       end
     else
       # Handle operation on numeric
       left = coerce_numeric(left, left_o, scope)
       right = coerce_numeric(right, right_o, scope)
       begin
         if operator == :'%' && (left.is_a?(Float) || right.is_a?(Float))
           # Deny users the fun of seeing severe rounding errors and confusing results
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         result = left.send(operator, right)
       rescue NoMethodError => e
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
       rescue ZeroDivisionError => e
         fail(Issues::DIV_BY_ZERO, right_o)
       end
       if result == INFINITY || result == -INFINITY
         fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
       end
       result
     end
   end
 
+  def eval_RenderStringExpression(o, scope)
+    scope["@epp"] << o.value.dup
+    nil
+  end
+
+  def eval_RenderExpression(o, scope)
+    scope["@epp"] << string(evaluate(o.expr, scope), scope)
+    nil
+  end
+
   # Evaluates Puppet DSL ->, ~>, <-, and <~
   def eval_RelationshipExpression(o, scope)
     # First level evaluation, reduction to basic data types or puppet types, the relationship operator then translates this
     # to the final set of references (turning strings into references, which can not naturally be done by the main evaluator since
     # all strings should not be turned into references.
     #
     real = eval_BinaryExpression(o, scope)
     @@relationship_operator.evaluate(real, o, scope)
   end
 
   # Evaluates x[key, key, ...]
   #
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     keys = o.keys.nil? ? [] : o.keys.collect {|key| evaluate(key, scope) }
     Puppet::Pops::Evaluator::AccessOperator.new(o).access(left, scope, *keys)
   end
 
   # Evaluates <, <=, >, >=, and ==
   #
   def eval_ComparisonExpression o, scope
     left, right = eval_BinaryExpression o, scope
 
     begin
     # Left is a type
     if left.is_a?(Puppet::Pops::Types::PAbstractType)
       case o.operator
       when :'=='
         @@type_calculator.equals(left,right)
 
       when :'!='
         !@@type_calculator.equals(left,right)
 
       when :'<'
         # left can be assigned to right, but they are not equal
         @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
       when :'<='
         # left can be assigned to right
         @@type_calculator.assignable?(right, left)
       when :'>'
         # right can be assigned to left, but they are not equal
         @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
       when :'>='
         # right can be assigned to left
         @@type_calculator.assignable?(left, right)
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     else
       case o.operator
       when :'=='
         @@compare_operator.equals(left,right)
       when :'!='
         ! @@compare_operator.equals(left,right)
       when :'<'
         @@compare_operator.compare(left,right) < 0
       when :'<='
         @@compare_operator.compare(left,right) <= 0
       when :'>'
         @@compare_operator.compare(left,right) > 0
       when :'>='
         @@compare_operator.compare(left,right) >= 0
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     end
     rescue ArgumentError => e
       fail(Issues::COMPARISON_NOT_POSSIBLE, o, {
         :operator => o.operator,
         :left_value => left,
         :right_value => right,
         :detail => e.message}, e)
     end
   end
 
   # Evaluates matching expressions with type, string or regexp rhs expression.
   # If RHS is a type, the =~ matches compatible (assignable?) type.
   #
   # @example
   #   x =~ /abc.*/
   # @example
   #   x =~ "abc.*/"
   # @example
   #   y = "abc"
   #   x =~ "${y}.*"
   # @example
   #   [1,2,3] =~ Array[Integer[1,10]]
   # @return [Boolean] if a match was made or not. Also sets $0..$n to matchdata in current scope.
   #
   def eval_MatchExpression o, scope
     left, pattern = eval_BinaryExpression o, scope
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
     if pattern.is_a?(Puppet::Pops::Types::PAbstractType)
       if pattern.is_a?(Puppet::Pops::Types::PRegexpType) && pattern.pattern
         # A qualified PRegexpType, get its ruby regexp
         pattern = pattern.regexp
       else
         # evaluate as instance?
         matched = @@type_calculator.instance?(pattern, left)
         # convert match result to Boolean true, or false
         return o.operator == :'=~' ? !!matched : !matched
       end
     end
 
     begin
       pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
     rescue StandardError => e
       fail(Issues::MATCH_NOT_REGEXP, o.right_expr, {:detail => e.message}, e)
     end
     unless left.is_a?(String)
       fail(Issues::MATCH_NOT_STRING, o.left_expr, {:left_value => left})
     end
 
     matched = pattern.match(left) # nil, or MatchData
     set_match_data(matched, o, scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
     o.operator == :'=~' ? !!matched : !matched
   end
 
   # Evaluates Puppet DSL `in` expression
   #
   def eval_InExpression o, scope
     left, right = eval_BinaryExpression o, scope
     @@compare_operator.include?(right, left)
   end
 
   # @example
   #   $a and $b
   # b is only evaluated if a is true
   #
   def eval_AndExpression o, scope
     is_true?(evaluate(o.left_expr, scope)) ? is_true?(evaluate(o.right_expr, scope)) : false
   end
 
   # @example
   #   a or b
   # b is only evaluated if a is false
   #
   def eval_OrExpression o, scope
     is_true?(evaluate(o.left_expr, scope)) ? true : is_true?(evaluate(o.right_expr, scope))
   end
 
   # Evaluates each entry of the literal list and creates a new Array
   # @return [Array] with the evaluated content
   #
   def eval_LiteralList o, scope
     o.values.collect {|expr| evaluate(expr, scope)}
   end
 
   # Evaluates each entry of the literal hash and creates a new Hash.
   # @return [Hash] with the evaluated content
   #
   def eval_LiteralHash o, scope
     h = Hash.new
     o.entries.each {|entry| h[ evaluate(entry.key, scope)]= evaluate(entry.value, scope)}
     h
   end
 
   # Evaluates all statements and produces the last evaluated value
   #
   def eval_BlockExpression o, scope
     r = nil
     o.statements.each {|s| r = evaluate(s, scope)}
     r
   end
 
   # Performs optimized search over case option values, lazily evaluating each
   # until there is a match. If no match is found, the case expression's default expression
   # is evaluated (it may be nil or Nop if there is no default, thus producing nil).
   # If an option matches, the result of evaluating that option is returned.
   # @return [Object, nil] what a matched option returns, or nil if nothing matched.
   #
   def eval_CaseExpression(o, scope)
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the case expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.test, scope)
       result = nil
       the_default = nil
       if o.options.find do |co|
         # the first case option that matches
         if co.values.find do |c|
           the_default = co.then_expr if c.is_a? Puppet::Pops::Model::LiteralDefault
           is_match?(test, evaluate(c, scope), c, scope)
         end
         result = evaluate(co.then_expr, scope)
         true # the option was picked
         end
       end
         result # an option was picked, and produced a result
       else
         evaluate(the_default, scope) # evaluate the default (should be a nop/nil) if there is no default).
       end
     end
   end
 
   # Evaluates a CollectExpression by transforming it into a 3x AST::Collection and then evaluating that.
   # This is done because of the complex API between compiler, indirector, backends, and difference between
   # collecting virtual resources and exported resources.
   #
   def eval_CollectExpression o, scope
     # The Collect Expression and its contained query expressions are implemented in such a way in
     # 3x that it is almost impossible to do anything about them (the AST objects are lazily evaluated,
     # and the built structure consists of both higher order functions and arrays with query expressions
     # that are either used as a predicate filter, or given to an indirection terminus (such as the Puppet DB
     # resource terminus). Unfortunately, the 3x implementation has many inconsistencies that the implementation
     # below carries forward.
     #
     collect_3x = Puppet::Pops::Model::AstTransformer.new().transform(o)
     collected = collect_3x.evaluate(scope)
     # the 3x returns an instance of Parser::Collector (but it is only registered with the compiler at this
     # point and does not contain any valuable information (like the result)
     # Dilemma: If this object is returned, it is a first class value in the Puppet Language and we
     # need to be able to perform operations on it. We can forbid it from leaking by making CollectExpression
     # a non R-value. This makes it possible for the evaluator logic to make use of the Collector.
     collected
   end
 
   def eval_ParenthesizedExpression(o, scope)
     evaluate(o.expr, scope)
   end
 
   # This evaluates classes, nodes and resource type definitions to nil, since 3x:
   # instantiates them, and evaluates their parameters and body. This is achieved by
   # providing bridge AST classes in Puppet::Parser::AST::PopsBridge that bridges a
   # Pops Program and a Pops Expression.
   #
   # Since all Definitions are handled "out of band", they are treated as a no-op when
   # evaluated.
   #
   def eval_Definition(o, scope)
     nil
   end
 
   def eval_Program(o, scope)
     evaluate(o.body, scope)
   end
 
   # Produces Array[PObjectType], an array of resource references
   #
   def eval_ResourceExpression(o, scope)
     exported = o.exported
     virtual = o.virtual
     type_name = evaluate(o.type_name, scope)
     o.bodies.map do |body|
       titles = [evaluate(body.title, scope)].flatten
       evaluated_parameters = body.operations.map {|op| evaluate(op, scope) }
       create_resources(o, scope, virtual, exported, type_name, titles, evaluated_parameters)
     end.flatten.compact
   end
 
   def eval_ResourceOverrideExpression(o, scope)
     evaluated_resources = evaluate(o.resources, scope)
     evaluated_parameters = o.operations.map { |op| evaluate(op, scope) }
     create_resource_overrides(o, scope, [evaluated_resources].flatten, evaluated_parameters)
     evaluated_resources
   end
 
   # Produces 3x array of parameters
   def eval_AttributeOperation(o, scope)
     create_resource_parameter(o, scope, o.attribute_name, evaluate(o.value_expr, scope), o.operator)
   end
 
   # Sets default parameter values for a type, produces the type
   #
   def eval_ResourceDefaultsExpression(o, scope)
     type_name = o.type_ref.value # a QualifiedName's string value
     evaluated_parameters = o.operations.map {|op| evaluate(op, scope) }
     create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Produce the type
     evaluate(o.type_ref, scope)
   end
 
   # Evaluates function call by name.
   #
   def eval_CallNamedFunctionExpression(o, scope)
     # The functor expression is not evaluated, it is not possible to select the function to call
     # via an expression like $a()
     unless o.functor_expr.is_a? Puppet::Pops::Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = o.functor_expr.value
     assert_function_available(name, o, scope)
     evaluated_arguments = o.arguments.collect {|arg| evaluate(arg, scope) }
     # wrap lambda in a callable block if it is present
     evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
     call_function(name, evaluated_arguments, o, scope) do |result|
       # prevent functions that are not r-value from leaking its return value
       rvalue_function?(name, o, scope) ? result : nil
     end
   end
 
   # Evaluation of CallMethodExpression handles a NamedAccessExpression functor (receiver.function_name)
   #
   def eval_CallMethodExpression(o, scope)
     unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
     receiver = evaluate(o.functor_expr.left_expr, scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Puppet::Pops::Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end 
     name = name.value # the string function name
     assert_function_available(name, o, scope)
     evaluated_arguments = [receiver] + (o.arguments || []).collect {|arg| evaluate(arg, scope) }
     evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
     call_function(name, evaluated_arguments, o, scope) do |result|
       # prevent functions that are not r-value from leaking its return value
       rvalue_function?(name, o, scope) ? result : nil
     end
   end
 
   # @example
   #   $x ? { 10 => true, 20 => false, default => 0 }
   #
   def eval_SelectorExpression o, scope
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the selector expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
       selected = o.selectors.find do |s|
         candidate = evaluate(s.matching_expr, scope)
         candidate == :default || is_match?(test, candidate, s.matching_expr, scope)
       end
       if selected
         evaluate(selected.value_expr, scope)
       else
         nil
       end
     end
   end
 
   # SubLocatable is simply an expression that holds location information
   def eval_SubLocatedExpression o, scope
     evaluate(o.expr, scope)
   end
 
   # Evaluates Puppet DSL Heredoc
   def eval_HeredocExpression o, scope
     result = evaluate(o.text_expr, scope)
     assert_external_syntax(scope, result, o.syntax, o.text_expr)
     result
   end
 
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
     with_guarded_scope(scope) do
       if is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
     with_guarded_scope(scope) do
       unless is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates a variable (getting its value)
   # The evaluator is lenient; any expression producing a String is used as a name
   # of a variable.
   #
   def eval_VariableExpression o, scope
     # Evaluator is not too fussy about what constitutes a name as long as the result
     # is a String and a valid variable name
     #
     name = evaluate(o.expr, scope)
 
     # Should be caught by validation, but make this explicit here as well, or mysterious evaluation issues
     # may occur.
     case name
     when String
     when Numeric
     else
       fail(Issues::ILLEGAL_VARIABLE_EXPRESSION, o.expr)
     end
     # TODO: Check for valid variable name (Task for validator)
     # TODO: semantics of undefined variable in scope, this just returns what scope does == value or nil
     get_variable_value(name, o, scope)
   end
 
   # Evaluates double quoted strings that may contain interpolation
   #
   def eval_ConcatenatedString o, scope
     o.segments.collect {|expr| string(evaluate(expr, scope), scope)}.join
   end
 
 
   # If the wrapped expression is a QualifiedName, it is taken as the name of a variable in scope.
   # Note that this is different from the 3.x implementation, where an initial qualified name
   # is accepted. (e.g. `"---${var + 1}---"` is legal. This implementation requires such concrete
   # syntax to be expressed in a model as `(TextExpression (+ (Variable var) 1)` - i.e. moving the decision to
   # the parser.
   #
   # Semantics; the result of an expression is turned into a string, nil is silently transformed to empty
   # string.
   # @return [String] the interpolated result
   #
   def eval_TextExpression o, scope
     if o.expr.is_a?(Puppet::Pops::Model::QualifiedName)
       # TODO: formalize, when scope returns nil, vs error
       string(get_variable_value(o.expr.value, o, scope), scope)
     else
       string(evaluate(o.expr, scope), scope)
     end
   end
 
   def string_Object(o, scope)
     o.to_s
   end
 
   def string_Symbol(o, scope)
     case o
     when :undef
       ''
     else
       o.to_s
     end
   end
 
   def string_Array(o, scope) 
     ['[', o.map {|e| string(e, scope)}.join(', '), ']'].join()
   end
 
   def string_Hash(o, scope)
     ['{', o.map {|k,v| string(k, scope) + " => " + string(v, scope)}.join(', '), '}'].join()
   end
 
   def string_Regexp(o, scope)
     ['/', o.source, '/'].join()
   end
 
   def string_PAbstractType(o, scope)
     @@type_calculator.string(o)
   end
 
   # Produces concatenation / merge of x and y.
   #
   # When x is an Array, y of type produces:
   #
   # * Array => concatenation `[1,2], [3,4] => [1,2,3,4]`
   # * Hash => concatenation of hash as array `[key, value, key, value, ...]`
   # * any other => concatenation of single value
   #
   # When x is a Hash, y of type produces:
   #
   # * Array => merge of array interpreted as `[key, value, key, value,...]`
   # * Hash => a merge, where entries in `y` overrides
   # * any other => error
   #
   # When x is something else, wrap it in an array first.
   #
   # When x is nil, an empty array is used instead.
   #
   # @note to concatenate an Array, nest the array - i.e. `[1,2], [[2,3]]`
   #
   # @overload concatenate(obj_x, obj_y)
   #   @param obj_x [Object] object to wrap in an array and concatenate to; see other overloaded methods for return type
   #   @param ary_y [Object] array to concatenate at end of `ary_x`
   #   @return [Object] wraps obj_x in array before using other overloaded option based on type of obj_y
   # @overload concatenate(ary_x, ary_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param ary_y [Array] array to concatenate at end of `ary_x`
   #   @return [Array] new array with `ary_x` + `ary_y`
   # @overload concatenate(ary_x, hsh_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param hsh_y [Hash] converted to array form, and concatenated to array
   #   @return [Array] new array with `ary_x` + `hsh_y` converted to array
   # @overload concatenate (ary_x, obj_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param obj_y [Object] non array or hash object to add to array
   #   @return [Array] new array with `ary_x` + `obj_y` added as last entry
   # @overload concatenate(hsh_x, ary_y)
   #   @param hsh_x [Hash] the hash to merge with
   #   @param ary_y [Array] array interpreted as even numbered sequence of key, value merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `ary_y` interpreted as hash in array form
   # @overload concatenate(hsh_x, hsh_y)
   #   @param hsh_x [Hash] the hash to merge to
   #   @param hsh_y [Hash] hash merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `hsh_y`
   # @raise [ArgumentError] when `xxx_x` is neither an Array nor a Hash
   # @raise [ArgumentError] when `xxx_x` is a Hash, and `xxx_y` is neither Array nor Hash.
   #
   def concatenate(x, y)
     x = [x] unless x.is_a?(Array) || x.is_a?(Hash)
     case x
     when Array
       y = case y
       when Array then y
       when Hash  then y.to_a
       else
         [y]
       end
       x + y # new array with concatenation
     when Hash
       y = case y
       when Hash then y
       when Array
         # Hash[[a, 1, b, 2]] => {}
         # Hash[a,1,b,2] => {a => 1, b => 2}
         # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
         # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
         # Use type calcultor to determine if array is Array[Array[?]], and if so use second form
         # of call
         t = @@type_calculator.infer(y)
         if t.element_type.is_a? Puppet::Pops::Types::PArrayType
           Hash[y]
         else
           Hash[*y]
         end
       else
         raise ArgumentError.new("Can only append Array or Hash to a Hash")
       end
       x.merge y # new hash with overwrite
     else
       raise ArgumentError.new("Can only append to an Array or a Hash.")
     end
   end
 
   # Produces the result x \ y (set difference)
   # When `x` is an Array, `y` is transformed to an array and then all matching elements removed from x.
   # When `x` is a Hash, all contained keys are removed from x as listed in `y` if it is an Array, or all its keys if it is a Hash.
   # The difference is returned. The given `x` and `y` are not modified by this operation.
   # @raise [ArgumentError] when `x` is neither an Array nor a Hash
   #
   def delete(x, y)
     result = x.dup
     case x
     when Array
       y = case y
       when Array then y
       when Hash then y.to_a
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     when Hash
       y = case y
       when Array then y
       when Hash then y.keys
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     else
       raise ArgumentError.new("Can only delete from an Array or Hash.")
     end
     result
   end
 
   # Implementation of case option matching.
   #
   # This is the type of matching performed in a case option, using == for every type
   # of value except regular expression where a match is performed.
   #
   def is_match? left, right, o, scope
     if right.is_a?(Regexp)
       return false unless left.is_a? String
       matched = right.match(left)
       set_match_data(matched, o, scope) # creates or clears ephemeral
       !!matched # convert to boolean
     elsif right.is_a?(Puppet::Pops::Types::PAbstractType)
       # right is a type and left is not - check if left is an instance of the given type
       # (The reverse is not terribly meaningful - computing which of the case options that first produces
       # an instance of a given type).
       #
       @@type_calculator.instance?(right, left)
     else
       # Handle equality the same way as the language '==' operator (case insensitive etc.)
       @@compare_operator.equals(left,right)
     end
   end
 
   def with_guarded_scope(scope)
     scope_memo = get_scope_nesting_level(scope)
     begin
       yield
     ensure
       set_scope_nesting_level(scope, scope_memo)
     end
   end
 
 end
diff --git a/lib/puppet/pops/model/factory.rb b/lib/puppet/pops/model/factory.rb
index 3e22c0fe8..075332bad 100644
--- a/lib/puppet/pops/model/factory.rb
+++ b/lib/puppet/pops/model/factory.rb
@@ -1,922 +1,929 @@
 # Factory is a helper class that makes construction of a Pops Model
 # much more convenient. It can be viewed as a small internal DSL for model
 # constructions.
 # For usage see tests using the factory.
 #
 # @todo All those uppercase methods ... they look bad in one way, but stand out nicely in the grammar...
 #   decide if they should change into lower case names (some of the are lower case)...
 #
 class Puppet::Pops::Model::Factory
   Model = Puppet::Pops::Model
 
   attr_accessor :current
 
   alias_method :model, :current
 
   # Shared build_visitor, since there are many instances of Factory being used
   @@build_visitor = Puppet::Pops::Visitor.new(self, "build")
   @@interpolation_visitor = Puppet::Pops::Visitor.new(self, "interpolate")
 
   # Initialize a factory with a single object, or a class with arguments applied to build of
   # created instance
   #
   def initialize o, *args
     @current = case o
     when Model::PopsObject
       o
     when Puppet::Pops::Model::Factory
       o.current
     else
       build(o, *args)
     end
   end
 
   # Polymorphic build
   def build(o, *args)
     begin
       @@build_visitor.visit_this(self, o, *args)
     rescue =>e
       # debug here when in trouble...
       raise e
     end
   end
 
   # Polymorphic interpolate
   def interpolate()
     begin
       @@interpolation_visitor.visit_this_0(self, current)
     rescue =>e
       # debug here when in trouble...
       raise e
     end
   end
 
   # Building of Model classes
 
   def build_ArithmeticExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   def build_AssignmentExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   def build_AttributeOperation(o, name, op, value)
     o.operator = op
     o.attribute_name = name.to_s # BOOLEAN is allowed in the grammar
     o.value_expr = build(value)
     o
   end
 
   def build_AccessExpression(o, left, *keys)
     o.left_expr = to_ops(left)
     keys.each {|expr| o.addKeys(to_ops(expr)) }
     o
   end
 
   def build_BinaryExpression(o, left, right)
     o.left_expr = to_ops(left)
     o.right_expr = to_ops(right)
     o
   end
 
   def build_BlockExpression(o, *args)
     args.each {|expr| o.addStatements(to_ops(expr)) }
     o
   end
 
   def build_CollectExpression(o, type_expr, query_expr, attribute_operations)
     o.type_expr = to_ops(type_expr)
     o.query = build(query_expr)
     attribute_operations.each {|op| o.addOperations(build(op)) }
     o
   end
 
   def build_ComparisonExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   def build_ConcatenatedString(o, *args)
     args.each {|expr| o.addSegments(build(expr)) }
     o
   end
 
   def build_CreateTypeExpression(o, name, super_name = nil)
     o.name = name
     o.super_name = super_name
     o
   end
 
   def build_CreateEnumExpression(o, *args)
     o.name = args.slice(0) if args.size == 2
     o.values = build(args.last)
     o
   end
 
   def build_CreateAttributeExpression(o, name, datatype_expr)
     o.name = name
     o.type = to_ops(datatype_expr)
     o
   end
 
   def build_HeredocExpression(o, name, expr)
     o.syntax = name
     o.text_expr = build(expr)
     o
   end
 
   # @param name [String] a valid classname
   # @param parameters [Array<Model::Parameter>] may be empty
   # @param parent_class_name [String, nil] a valid classname referencing a parent class, optional.
   # @param body [Array<Expression>, Expression, nil] expression that constitute the body
   # @return [Model::HostClassDefinition] configured from the parameters
   #
   def build_HostClassDefinition(o, name, parameters, parent_class_name, body)
     build_NamedDefinition(o, name, parameters, body)
     o.parent_class = parent_class_name if parent_class_name
     o
   end
 
   def build_ResourceOverrideExpression(o, resources, attribute_operations)
     o.resources = build(resources)
     attribute_operations.each {|ao| o.addOperations(build(ao)) }
     o
   end
 
   def build_KeyedEntry(o, k, v)
     o.key = build(k)
     o.value = build(v)
     o
   end
 
   def build_LiteralHash(o, *keyed_entries)
     keyed_entries.each {|entry| o.addEntries build(entry) }
     o
   end
 
   def build_LiteralList(o, *values)
     values.each {|v| o.addValues build(v) }
     o
   end
 
   def build_LiteralFloat(o, val)
     o.value = val
     o
   end
 
   def build_LiteralInteger(o, val, radix)
     o.value = val
     o.radix = radix
     o
   end
 
   def build_IfExpression(o, t, ift, els)
     o.test = build(t)
     o.then_expr = build(ift)
     o.else_expr= build(els)
     o
   end
 
   def build_MatchExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   # Builds body :) from different kinds of input
   # @overload f_build_body(nothing)
   #   @param nothing [nil] unchanged, produces nil
   # @overload f_build_body(array)
   #   @param array [Array<Expression>] turns into a BlockExpression
   # @overload f_build_body(expr)
   #   @param expr [Expression] produces the given expression
   # @overload f_build_body(obj)
   #   @param obj [Object] produces the result of calling #build with body as argument
   def f_build_body(body)
     case body
     when NilClass
       nil
     when Array
       Puppet::Pops::Model::Factory.new(Model::BlockExpression, *body)
     else
       build(body)
     end
   end
 
   def build_LambdaExpression(o, parameters, body)
     parameters.each {|p| o.addParameters(build(p)) }
     b = f_build_body(body)
     o.body = b.current if b
     o
   end
 
   def build_NamedDefinition(o, name, parameters, body)
     parameters.each {|p| o.addParameters(build(p)) }
     b = f_build_body(body)
     o.body = b.current if b
     o.name = name
     o
   end
 
   # @param o [Model::NodeDefinition]
   # @param hosts [Array<Expression>] host matches
   # @param parent [Expression] parent node matcher
   # @param body [Object] see {#f_build_body}
   def build_NodeDefinition(o, hosts, parent, body)
     hosts.each {|h| o.addHost_matches(build(h)) }
     o.parent = build(parent) if parent # no nop here
     b = f_build_body(body)
     o.body = b.current if b
     o
   end
 
   def build_Parameter(o, name, expr)
     o.name = name
     o.value = build(expr) if expr # don't build a nil/nop
     o
   end
 
   def build_QualifiedReference(o, name)
     o.value = name.to_s.downcase
     o
   end
 
   def build_RelationshipExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   def build_ResourceExpression(o, type_name, bodies)
     o.type_name = build(type_name)
     bodies.each {|b| o.addBodies(build(b)) }
     o
   end
 
   def build_RenderStringExpression(o, string)
     o.value = string;
     o
   end
 
   def build_ResourceBody(o, title_expression, attribute_operations)
     o.title = build(title_expression)
     attribute_operations.each {|ao| o.addOperations(build(ao)) }
     o
   end
 
   def build_ResourceDefaultsExpression(o, type_ref, attribute_operations)
     o.type_ref = build(type_ref)
     attribute_operations.each {|ao| o.addOperations(build(ao)) }
     o
   end
 
   def build_SelectorExpression(o, left, *selectors)
     o.left_expr = to_ops(left)
     selectors.each {|s| o.addSelectors(build(s)) }
     o
   end
 
   # Builds a SubLocatedExpression - this wraps the expression in a sublocation configured
   # from the given token
   # A SubLocated holds its own locator that is used for subexpressions holding positions relative
   # to what it describes.
   #
   def build_SubLocatedExpression(o, token, expression)
     o.expr = build(expression)
     o.offset = token.offset
     o.length =  token.length
     locator = token.locator
     o.locator = locator
     o.leading_line_count = locator.leading_line_count
     o.leading_line_offset = locator.leading_line_offset
     # Index is held in sublocator's parent locator - needed to be able to reconstruct
     o.line_offsets = locator.locator.line_index
     o
   end
 
   def build_SelectorEntry(o, matching, value)
     o.matching_expr = build(matching)
     o.value_expr = build(value)
     o
   end
 
   def build_QueryExpression(o, expr)
     ops = to_ops(expr)
     o.expr = ops unless Puppet::Pops::Model::Factory.nop? ops
     o
   end
 
   def build_UnaryExpression(o, expr)
     ops = to_ops(expr)
     o.expr = ops unless Puppet::Pops::Model::Factory.nop? ops
     o
   end
 
   def build_Program(o, body, definitions, locator)
     o.body = to_ops(body)
     # non containment
     definitions.each { |d| o.addDefinitions(d) }
     o.source_ref = locator.file
     o.source_text = locator.string
     o.line_offsets = locator.line_index
     o.locator = locator
     o
   end
 
   def build_QualifiedName(o, name)
     o.value = name.to_s
     o
   end
 
   # Puppet::Pops::Model::Factory helpers
   def f_build_unary(klazz, expr)
     Puppet::Pops::Model::Factory.new(build(klazz.new, expr))
   end
 
   def f_build_binary_op(klazz, op, left, right)
     Puppet::Pops::Model::Factory.new(build(klazz.new, op, left, right))
   end
 
   def f_build_binary(klazz, left, right)
     Puppet::Pops::Model::Factory.new(build(klazz.new, left, right))
   end
 
   def f_build_vararg(klazz, left, *arg)
     Puppet::Pops::Model::Factory.new(build(klazz.new, left, *arg))
   end
 
   def f_arithmetic(op, r)
     f_build_binary_op(Model::ArithmeticExpression, op, current, r)
   end
 
   def f_comparison(op, r)
     f_build_binary_op(Model::ComparisonExpression, op, current, r)
   end
 
   def f_match(op, r)
     f_build_binary_op(Model::MatchExpression, op, current, r)
   end
 
   # Operator helpers
   def in(r)     f_build_binary(Model::InExpression, current, r);          end
 
   def or(r)     f_build_binary(Model::OrExpression, current, r);          end
 
   def and(r)    f_build_binary(Model::AndExpression, current, r);         end
 
   def not();    f_build_unary(Model::NotExpression, self);                end
 
   def minus();  f_build_unary(Model::UnaryMinusExpression, self);         end
 
   def text();   f_build_unary(Model::TextExpression, self);               end
 
   def var();    f_build_unary(Model::VariableExpression, self);           end
 
   def [](*r);   f_build_vararg(Model::AccessExpression, current, *r);     end
 
   def dot r;    f_build_binary(Model::NamedAccessExpression, current, r); end
 
   def + r;      f_arithmetic(:+, r);                                      end
 
   def - r;      f_arithmetic(:-, r);                                      end
 
   def / r;      f_arithmetic(:/, r);                                      end
 
   def * r;      f_arithmetic(:*, r);                                      end
 
   def % r;      f_arithmetic(:%, r);                                      end
 
   def << r;     f_arithmetic(:<<, r);                                     end
 
   def >> r;     f_arithmetic(:>>, r);                                     end
 
   def < r;      f_comparison(:<, r);                                      end
 
   def <= r;     f_comparison(:<=, r);                                     end
 
   def > r;      f_comparison(:>, r);                                      end
 
   def >= r;     f_comparison(:>=, r);                                     end
 
   def == r;     f_comparison(:==, r);                                     end
 
   def ne r;     f_comparison(:'!=', r);                                   end
 
   def =~ r;     f_match(:'=~', r);                                        end
 
   def mne r;    f_match(:'!~', r);                                        end
 
   def paren();  f_build_unary(Model::ParenthesizedExpression, current);   end
 
   def relop op, r
     f_build_binary_op(Model::RelationshipExpression, op.to_sym, current, r)
   end
 
   def select *args
     Puppet::Pops::Model::Factory.new(build(Model::SelectorExpression, current, *args))
   end
 
   # For CaseExpression, setting the default for an already build CaseExpression
   def default r
     current.addOptions(Puppet::Pops::Model::Factory.WHEN(:default, r).current)
     self
   end
 
   def lambda=(lambda)
     current.lambda = lambda.current
     self
   end
 
   # Assignment =
   def set(r)
     f_build_binary_op(Model::AssignmentExpression, :'=', current, r)
   end
 
   # Assignment +=
   def plus_set(r)
     f_build_binary_op(Model::AssignmentExpression, :'+=', current, r)
   end
 
   # Assignment -=
   def minus_set(r)
     f_build_binary_op(Model::AssignmentExpression, :'-=', current, r)
   end
 
   def attributes(*args)
     args.each {|a| current.addAttributes(build(a)) }
     self
   end
 
   # Catch all delegation to current
   def method_missing(meth, *args, &block)
     if current.respond_to?(meth)
       current.send(meth, *args, &block)
     else
       super
     end
   end
 
   def respond_to?(meth, include_all=false)
     current.respond_to?(meth, include_all) || super
   end
 
   # Records the position (start -> end) and computes the resulting length.
   #
   def record_position(start_locatable, end_locatable)
     from = start_locatable.is_a?(Puppet::Pops::Model::Factory) ? start_locatable.current : start_locatable
     to   = end_locatable.is_a?(Puppet::Pops::Model::Factory) ? end_locatable.current  : end_locatable
     to = from if to.nil?
     o = current
     # record information directly in the Model::Positioned object
     o.offset = from.offset
     o.length ||= to.offset - from.offset + to.length
     self
   end
 
   # @return [Puppet::Pops::Adapters::SourcePosAdapter] with location information
   def loc()
     Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
   end
 
   # Returns symbolic information about an expected share of a resource expression given the LHS of a resource expr.
   #
   # * `name { }` => `:resource`,  create a resource of the given type
   # * `Name { }` => ':defaults`, set defaults for the referenced type
   # * `Name[] { }` => `:override`, overrides instances referenced by LHS
   # * _any other_ => ':error', all other are considered illegal
   #
   def self.resource_shape(expr)
     expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
     case expr
     when Model::QualifiedName
       :resource
     when Model::QualifiedReference
       :defaults
     when Model::AccessExpression
       :override
     when 'class'
       :class
     else
       :error
     end
   end
   # Factory starting points
 
   def self.literal(o);                   new(o);                                                 end
 
   def self.minus(o);                     new(o).minus;                                           end
 
   def self.var(o);                       new(o).var;                                             end
 
   def self.block(*args);                 new(Model::BlockExpression, *args);                     end
 
   def self.string(*args);                new(Model::ConcatenatedString, *args);                  end
 
   def self.text(o);                      new(o).text;                                            end
 
   def self.IF(test_e,then_e,else_e);     new(Model::IfExpression, test_e, then_e, else_e);       end
 
   def self.UNLESS(test_e,then_e,else_e); new(Model::UnlessExpression, test_e, then_e, else_e);   end
 
   def self.CASE(test_e,*options);        new(Model::CaseExpression, test_e, *options);           end
 
   def self.WHEN(values_list, block);     new(Model::CaseOption, values_list, block);             end
 
   def self.MAP(match, value);            new(Model::SelectorEntry, match, value);                end
 
   def self.TYPE(name, super_name=nil);   new(Model::CreateTypeExpression, name, super_name);     end
 
   def self.ATTR(name, type_expr=nil);    new(Model::CreateAttributeExpression, name, type_expr); end
 
   def self.ENUM(*args);                  new(Model::CreateEnumExpression, *args);                end
 
   def self.KEY_ENTRY(key, val);          new(Model::KeyedEntry, key, val);                       end
 
   def self.HASH(entries);                new(Model::LiteralHash, *entries);                      end
 
   # TODO_HEREDOC
   def self.HEREDOC(name, expr);          new(Model::HeredocExpression, name, expr);              end
 
   def self.SUBLOCATE(token, expr)        new(Model::SubLocatedExpression, token, expr);          end
 
   def self.LIST(entries);                new(Model::LiteralList, *entries);                      end
 
   def self.PARAM(name, expr=nil);        new(Model::Parameter, name, expr);                      end
 
   def self.NODE(hosts, parent, body);    new(Model::NodeDefinition, hosts, parent, body);        end
 
   # Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which
   # case it is returned.
   #
   def self.fqn(o)
     o = o.current if o.is_a?(Puppet::Pops::Model::Factory)
     o = new(Model::QualifiedName, o) unless o.is_a? Model::QualifiedName
     o
   end
 
   # Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which
   # case it is returned.
   #
   def self.fqr(o)
     o = o.current if o.is_a?(Puppet::Pops::Model::Factory)
     o = new(Model::QualifiedReference, o) unless o.is_a? Model::QualifiedReference
     o
   end
 
   def self.TEXT(expr)
     new(Model::TextExpression, new(expr).interpolate)
   end
 
   # TODO_EPP
   def self.RENDER_STRING(o)
     new(Model::RenderStringExpression, o)
   end
 
   def self.RENDER_EXPR(expr)
     new(Model::RenderExpression, expr)
   end
 
   def self.EPP(parameters, body)
     new(Model::EppExpression, parameters, body)
   end
 
   # TODO: This is the same a fqn factory method, don't know if callers to fqn and QNAME can live with the
   # same result or not yet - refactor into one method when decided.
   #
   def self.QNAME(name)
     new(Model::QualifiedName, name)
   end
 
   def self.NUMBER(name_or_numeric)
     if n_radix = Puppet::Pops::Utils.to_n_with_radix(name_or_numeric)
       val, radix = n_radix
       if val.is_a?(Float)
         new(Model::LiteralFloat, val)
       else
         new(Model::LiteralInteger, val, radix)
       end
     else
       # Bad number should already have been caught by lexer - this should never happen
       raise ArgumentError, "Internal Error, NUMBER token does not contain a valid number, #{name_or_numeric}"
     end
   end
 
   # Convert input string to either a qualified name, a LiteralInteger with radix, or a LiteralFloat
   #
   def self.QNAME_OR_NUMBER(name)
     if n_radix = Puppet::Pops::Utils.to_n_with_radix(name)
       val, radix = n_radix
       if val.is_a?(Float)
         new(Model::LiteralFloat, val)
       else
         new(Model::LiteralInteger, val, radix)
       end
     else
       new(Model::QualifiedName, name)
     end
   end
 
   def self.QREF(name)
     new(Model::QualifiedReference, name)
   end
 
   def self.VIRTUAL_QUERY(query_expr)
     new(Model::VirtualQuery, query_expr)
   end
 
   def self.EXPORTED_QUERY(query_expr)
     new(Model::ExportedQuery, query_expr)
   end
 
   def self.ATTRIBUTE_OP(name, op, expr)
     new(Model::AttributeOperation, name, op, expr)
   end
 
   def self.CALL_NAMED(name, rval_required, argument_list)
     unless name.kind_of?(Model::PopsObject)
       name = Puppet::Pops::Model::Factory.fqn(name) unless name.is_a?(Puppet::Pops::Model::Factory)
     end
     new(Model::CallNamedFunctionExpression, name, rval_required, *argument_list)
   end
 
   def self.CALL_METHOD(functor, argument_list)
     new(Model::CallMethodExpression, functor, true, nil, *argument_list)
   end
 
   def self.COLLECT(type_expr, query_expr, attribute_operations)
     new(Model::CollectExpression, type_expr, query_expr, attribute_operations)
   end
 
   def self.NAMED_ACCESS(type_name, bodies)
     new(Model::NamedAccessExpression, type_name, bodies)
   end
 
   def self.RESOURCE(type_name, bodies)
     new(Model::ResourceExpression, type_name, bodies)
   end
 
   def self.RESOURCE_DEFAULTS(type_name, attribute_operations)
     new(Model::ResourceDefaultsExpression, type_name, attribute_operations)
   end
 
   def self.RESOURCE_OVERRIDE(resource_ref, attribute_operations)
     new(Model::ResourceOverrideExpression, resource_ref, attribute_operations)
   end
 
   def self.RESOURCE_BODY(resource_title, attribute_operations)
     new(Model::ResourceBody, resource_title, attribute_operations)
   end
 
   def self.PROGRAM(body, definitions, locator)
     new(Model::Program, body, definitions, locator)
   end
 
   # Builds a BlockExpression if args size > 1, else the single expression/value in args
   def self.block_or_expression(*args)
     if args.size > 1
       new(Model::BlockExpression, *args)
     else
       new(args[0])
     end
   end
 
   def self.HOSTCLASS(name, parameters, parent, body)
     new(Model::HostClassDefinition, name, parameters, parent, body)
   end
 
   def self.DEFINITION(name, parameters, body)
     new(Model::ResourceTypeDefinition, name, parameters, body)
   end
 
   def self.LAMBDA(parameters, body)
     new(Model::LambdaExpression, parameters, body)
   end
 
   def self.nop? o
     o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
   end
 
   # Transforms an array of expressions containing literal name expressions to calls if followed by an
   # expression, or expression list.
   #
   def self.transform_calls(expressions)
     expressions.reduce([]) do |memo, expr|
       expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
       name = memo[-1]
       if name.is_a? Model::QualifiedName
         memo[-1] = Puppet::Pops::Model::Factory.CALL_NAMED(name, false, expr.is_a?(Array) ? expr : [expr])
         if expr.is_a?(Model::CallNamedFunctionExpression)
           # Patch statement function call to expression style
           # This is needed because it is first parsed as a "statement" and the requirement changes as it becomes
           # an argument to the name to call transform above.
           expr.rval_required = true
         end
       else
         memo << expr
         if expr.is_a?(Model::CallNamedFunctionExpression)
           # Patch rvalue expression function call to statement style.
           # This is not really required but done to be AST model compliant
           expr.rval_required = false
         end
       end
       memo
     end
 
   end
 
   # Building model equivalences of Ruby objects
   # Allows passing regular ruby objects to the factory to produce instructions
   # that when evaluated produce the same thing.
 
   def build_String(o)
     x = Model::LiteralString.new
     x.value = o;
     x
   end
 
   def build_NilClass(o)
     x = Model::Nop.new
     x
   end
 
   def build_TrueClass(o)
     x = Model::LiteralBoolean.new
     x.value = o
     x
   end
 
   def build_FalseClass(o)
     x = Model::LiteralBoolean.new
     x.value = o
     x
   end
 
   def build_Fixnum(o)
     x = Model::LiteralInteger.new
     x.value = o;
     x
   end
 
   def build_Float(o)
     x = Model::LiteralFloat.new
     x.value = o;
     x
   end
 
   def build_Regexp(o)
     x = Model::LiteralRegularExpression.new
     x.value = o;
     x
   end
 
+  def build_EppExpression(o, parameters, body)
+    parameters.each {|p| o.addParameters(build(p)) }
+    b = f_build_body(body)
+    o.body = b.current if b
+    o
+  end
+
   # If building a factory, simply unwrap the model oject contained in the factory.
   def build_Factory(o)
     o.current
   end
 
   # Creates a String literal, unless the symbol is one of the special :undef, or :default
   # which instead creates a LiterlUndef, or a LiteralDefault.
   def build_Symbol(o)
     case o
     when :undef
       Model::LiteralUndef.new
     when :default
       Model::LiteralDefault.new
     else
       build_String(o.to_s)
     end
   end
 
   # Creates a LiteralList instruction from an Array, where the entries are built.
   def build_Array(o)
     x = Model::LiteralList.new
     o.each { |v| x.addValues(build(v)) }
     x
   end
 
   # Create a LiteralHash instruction from a hash, where keys and values are built
   # The hash entries are added in sorted order based on key.to_s
   #
   def build_Hash(o)
     x = Model::LiteralHash.new
     (o.sort_by {|k,v| k.to_s}).each {|k,v| x.addEntries(build(Model::KeyedEntry.new, k, v)) }
     x
   end
 
   # @param rval_required [Boolean] if the call must produce a value
   def build_CallExpression(o, functor, rval_required, *args)
     o.functor_expr = to_ops(functor)
     o.rval_required = rval_required
     args.each {|x| o.addArguments(to_ops(x)) }
     o
   end
 
   def build_CallMethodExpression(o, functor, rval_required, lambda, *args)
     build_CallExpression(o, functor, rval_required, *args)
     o.lambda = lambda
     o
   end
 
   def build_CaseExpression(o, test, *args)
     o.test = build(test)
     args.each {|opt| o.addOptions(build(opt)) }
     o
   end
 
   def build_CaseOption(o, value_list, then_expr)
     value_list = [value_list] unless value_list.is_a? Array
     value_list.each { |v| o.addValues(build(v)) }
     b = f_build_body(then_expr)
     o.then_expr = to_ops(b) if b
     o
   end
 
   # Build a Class by creating an instance of it, and then calling build on the created instance
   # with the given arguments
   def build_Class(o, *args)
     build(o.new(), *args)
   end
 
   def interpolate_Factory(o)
     interpolate(o.current)
   end
 
   def interpolate_LiteralInteger(o)
     # convert number to a variable
     self.class.new(o).var
   end
 
   def interpolate_Object(o)
     o
   end
 
   def interpolate_QualifiedName(o)
     self.class.new(o).var
   end
 
   # rewrite left expression to variable if it is name, number, and recurse if it is an access expression
   # this is for interpolation support in new lexer (${NAME}, ${NAME[}}, ${NUMBER}, ${NUMBER[]} - all
   # other expressions requires variables to be preceded with $
   #
   def interpolate_AccessExpression(o)
     if is_interop_rewriteable?(o.left_expr)
       o.left_expr = to_ops(self.class.new(o.left_expr).interpolate)
     end
     o
   end
 
   def interpolate_NamedAccessExpression(o)
     if is_interop_rewriteable?(o.left_expr)
         o.left_expr = to_ops(self.class.new(o.left_expr).interpolate)
     end
     o
   end
 
   # Rewrite method calls on the form ${x.each ...} to ${$x.each}
   def interpolate_CallMethodExpression(o)
     if is_interop_rewriteable?(o.functor_expr)
       o.functor_expr = to_ops(self.class.new(o.functor_expr).interpolate)
     end
     o
   end
 
   def is_interop_rewriteable?(o)
     case o
     when Model::AccessExpression, Model::QualifiedName,
       Model::NamedAccessExpression, Model::CallMethodExpression
       true
     when Model::LiteralInteger
       # Only decimal integers can represent variables, else it is a number
       o.radix == 10
     else
       false
     end
   end
 
   # Checks if the object is already a model object, or build it
   def to_ops(o, *args)
     case o
     when Model::PopsObject
       o
     when Puppet::Pops::Model::Factory
       o.current
     else
       build(o, *args)
     end
   end
 
   def self.concat(*args)
     new(args.map do |e|
       e = e.current if e.is_a?(self)
       case e
       when Model::LiteralString
         e.value
       when String
         e
       else
         raise ArgumentError, "can only concatenate strings, got #{e.class}"
       end
     end.join(''))
   end
 end
diff --git a/lib/puppet/pops/model/model.rb b/lib/puppet/pops/model/model.rb
index 48269a212..7b65812f1 100644
--- a/lib/puppet/pops/model/model.rb
+++ b/lib/puppet/pops/model/model.rb
@@ -1,604 +1,606 @@
 #
 # The Puppet Pops Metamodel
 #
 # This module contains a formal description of the Puppet Pops (*P*uppet *OP*eration instruction*S*).
 # It describes a Metamodel containing DSL instructions, a description of PuppetType and related
 # classes needed to evaluate puppet logic.
 # The metamodel resembles the existing AST model, but it is a semantic model of instructions and
 # the types that they operate on rather than an Abstract Syntax Tree, although closely related.
 #
 # The metamodel is anemic (has no behavior) except basic datatype and type
 # assertions and reference/containment assertions.
 # The metamodel is also a generalized description of the Puppet DSL to enable the
 # same metamodel to be used to express Puppet DSL models (instances) with different semantics as
 # the language evolves.
 #
 # The metamodel is concretized by a validator for a particular version of
 # the Puppet DSL language.
 #
 # This metamodel is expressed using RGen.
 #
 
 require 'rgen/metamodel_builder'
 
 module Puppet::Pops::Model
   extend RGen::MetamodelBuilder::ModuleExtension
 
   # A base class for modeled objects that makes them Visitable, and Adaptable.
   #
   class PopsObject < RGen::MetamodelBuilder::MMBase
     include Puppet::Pops::Visitable
     include Puppet::Pops::Adaptable
     include Puppet::Pops::Containment
     abstract
   end
 
   # A Positioned object has an offset measured in an opaque unit (representing characters) from the start
   # of a source text (starting
   # from 0), and a length measured in the same opaque unit. The resolution of the opaque unit requires the
   # aid of a Locator instance that knows about the measure. This information is stored in the model's
   # root node - a Program.
   #
   # The offset and length are optional if the source of the model is not from parsed text.
   #
   class Positioned < PopsObject
     abstract
     has_attr 'offset', Integer
     has_attr 'length', Integer
   end
 
   # @abstract base class for expressions
   class Expression < Positioned
     abstract
   end
 
   # A Nop - the "no op" expression.
   # @note not really needed since the evaluator can evaluate nil with the meaning of NoOp
   # @todo deprecate? May be useful if there is the need to differentiate between nil and Nop when transforming model.
   #
   class Nop < Expression
   end
 
   # A binary expression is abstract and has a left and a right expression. The order of evaluation
   # and semantics are determined by the concrete subclass.
   #
   class BinaryExpression < Expression
     abstract
     #
     # @!attribute [rw] left_expr
     #   @return [Expression]
     contains_one_uni 'left_expr', Expression, :lowerBound => 1
     contains_one_uni 'right_expr', Expression, :lowerBound => 1
   end
 
   # An unary expression is abstract and contains one expression. The semantics are determined by
   # a concrete subclass.
   #
   class UnaryExpression < Expression
     abstract
     contains_one_uni 'expr', Expression, :lowerBound => 1
   end
 
   # A class that simply evaluates to the contained expression.
   # It is of value in order to preserve user entered parentheses in transformations, and
   # transformations from model to source.
   #
   class ParenthesizedExpression < UnaryExpression; end
 
   # A boolean not expression, reversing the truth of the unary expr.
   #
   class NotExpression < UnaryExpression; end
 
   # An arithmetic expression reversing the polarity of the numeric unary expr.
   #
   class UnaryMinusExpression < UnaryExpression; end
 
   # An assignment expression assigns a value to the lval() of the left_expr.
   #
   class AssignmentExpression < BinaryExpression
     has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'=', :'+=', :'-=']), :lowerBound => 1
   end
 
   # An arithmetic expression applies an arithmetic operator on left and right expressions.
   #
   class ArithmeticExpression < BinaryExpression
     has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'+', :'-', :'*', :'%', :'/', :'<<', :'>>' ]), :lowerBound => 1
   end
 
   # A relationship expression associates the left and right expressions
   #
   class RelationshipExpression < BinaryExpression
     has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'->', :'<-', :'~>', :'<~']), :lowerBound => 1
   end
 
   # A binary expression, that accesses the value denoted by right in left. i.e. typically
   # expressed concretely in a language as left[right].
   #
   class AccessExpression < Expression
     contains_one_uni 'left_expr', Expression, :lowerBound => 1
     contains_many_uni 'keys', Expression, :lowerBound => 1
   end
 
   # A comparison expression compares left and right using a comparison operator.
   #
   class ComparisonExpression < BinaryExpression
     has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'==', :'!=', :'<', :'>', :'<=', :'>=' ]), :lowerBound => 1
   end
 
   # A match expression matches left and right using a matching operator.
   #
   class MatchExpression < BinaryExpression
     has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'!~', :'=~']), :lowerBound => 1
   end
 
   # An 'in' expression checks if left is 'in' right
   #
   class InExpression < BinaryExpression; end
 
   # A boolean expression applies a logical connective operator (and, or) to left and right expressions.
   #
   class BooleanExpression < BinaryExpression
     abstract
   end
 
   # An and expression applies the logical connective operator and to left and right expression
   # and does not evaluate the right expression if the left expression is false.
   #
   class AndExpression < BooleanExpression; end
 
   # An or expression applies the logical connective operator or to the left and right expression
   # and does not evaluate the right expression if the left expression is true
   #
   class OrExpression < BooleanExpression; end
 
   # A literal list / array containing 0:M expressions.
   #
   class LiteralList < Expression
     contains_many_uni 'values', Expression
   end
 
   # A Keyed entry has a key and a value expression. It is typically used as an entry in a Hash.
   #
   class KeyedEntry < Positioned
     contains_one_uni 'key', Expression, :lowerBound => 1
     contains_one_uni 'value', Expression, :lowerBound => 1
   end
 
   # A literal hash is a collection of KeyedEntry objects
   #
   class LiteralHash < Expression
     contains_many_uni 'entries', KeyedEntry
   end
 
   # A block contains a list of expressions
   #
   class BlockExpression < Expression
     contains_many_uni 'statements', Expression
   end
 
   # A case option entry in a CaseStatement
   #
   class CaseOption < Expression
     contains_many_uni 'values', Expression, :lowerBound => 1
     contains_one_uni 'then_expr', Expression, :lowerBound => 1
   end
 
   # A case expression has a test, a list of options (multi values => block map).
   # One CaseOption may contain a LiteralDefault as value. This option will be picked if nothing
   # else matched.
   #
   class CaseExpression < Expression
     contains_one_uni 'test', Expression, :lowerBound => 1
     contains_many_uni 'options', CaseOption
   end
 
   # A query expression is an expression that is applied to some collection.
   # The contained optional expression may contain different types of relational expressions depending
   # on what the query is applied to.
   #
   class QueryExpression < Expression
     abstract
     contains_one_uni 'expr', Expression, :lowerBound => 0
   end
 
   # An exported query is a special form of query that searches for exported objects.
   #
   class ExportedQuery < QueryExpression
   end
 
   # A virtual query is a special form of query that searches for virtual objects.
   #
   class VirtualQuery < QueryExpression
   end
 
   # An attribute operation sets or appends a value to a named attribute.
   #
   class AttributeOperation < Positioned
     has_attr 'attribute_name', String, :lowerBound => 1
     has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'=>', :'+>', ]), :lowerBound => 1
     contains_one_uni 'value_expr', Expression, :lowerBound => 1
   end
 
   # An object that collects stored objects from the central cache and returns
   # them to the current host. Operations may optionally be applied.
   #
   class CollectExpression < Expression
     contains_one_uni 'type_expr', Expression, :lowerBound => 1
     contains_one_uni 'query', QueryExpression, :lowerBound => 1
     contains_many_uni 'operations', AttributeOperation
   end
 
   class Parameter < Positioned
     has_attr 'name', String, :lowerBound => 1
     contains_one_uni 'value', Expression
   end
 
   # Abstract base class for definitions.
   #
   class Definition < Expression
     abstract
   end
 
   # Abstract base class for named and parameterized definitions.
   class NamedDefinition < Definition
     abstract
     has_attr 'name', String, :lowerBound => 1
     contains_many_uni 'parameters', Parameter
     contains_one_uni 'body', Expression
   end
 
   # A resource type definition (a 'define' in the DSL).
   #
   class ResourceTypeDefinition < NamedDefinition
   end
 
   # A node definition matches hosts using Strings, or Regular expressions. It may inherit from
   # a parent node (also using a String or Regular expression).
   #
   class NodeDefinition < Definition
     contains_one_uni 'parent', Expression
     contains_many_uni 'host_matches', Expression, :lowerBound => 1
     contains_one_uni 'body', Expression
   end
 
   class LocatableExpression < Expression
     has_many_attr 'line_offsets', Integer
     has_attr 'locator', Object, :lowerBound => 1, :transient => true
 
     module ClassModule
       # Go through the gymnastics of making either value or pattern settable
       # with synchronization to the other form. A derived value cannot be serialized
       # and we want to serialize the pattern. When recreating the object we need to
       # recreate it from the pattern string.
       # The below sets both values if one is changed.
       #
       def locator
         unless result = getLocator
           setLocator(result = Puppet::Pops::Parser::Locator.locator(source_text, source_ref(), line_offsets))
         end
         result
       end
     end
   end
 
   # Contains one expression which has offsets reported virtually (offset against the Program's
   # overall locator).
   #
   class SubLocatedExpression < Expression
     contains_one_uni 'expr', Expression, :lowerBound => 1
 
     # line offset index for contained expressions
     has_many_attr 'line_offsets', Integer
 
     # Number of preceding lines (before the line_offsets)
     has_attr 'leading_line_count', Integer
 
     # The offset of the leading source line (i.e. size of "left margin").
     has_attr 'leading_line_offset', Integer
 
     # The locator for the sub-locatable's children (not for the sublocator itself)
     # The locator is not serialized and is recreated on demand from the indexing information
     # in self.
     #
     has_attr 'locator', Object, :lowerBound => 1, :transient => true
 
     module ClassModule
       def locator
         unless result = getLocator
           # Adapt myself to get the Locator for me
           adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(self)
           # Get the program (root), and deal with case when not contained in a program
           program = eAllContainers.find {|c| c.is_a?(Program) }
           source_ref = program.nil? ? '' : program.source_ref
 
           # An outer locator is needed since SubLocator only deals with offsets. This outer locator
           # has 0,0 as origin.
           outer_locator = Puppet::Pops::Parser::Locator.locator(adpater.extract_text, source_ref, line_offsets)
 
           # Create a sublocator that describes an offset from the outer
           # NOTE: the offset of self is the same as the sublocator's leading_offset
           result = Puppet::Pops::Parser::Locator::SubLocator.new(outer_locator,
             leading_line_count, offset, leading_line_offset)
           setLocator(result)
         end
         result
       end
     end
   end
 
   # A heredoc is a wrapper around a LiteralString or a ConcatenatedStringExpression with a specification
   # of syntax. The expectation is that "syntax" has meaning to a validator. A syntax of nil or '' means
   # "unspecified syntax".
   #
   class HeredocExpression < Expression
     has_attr 'syntax', String
     contains_one_uni 'text_expr', Expression, :lowerBound => 1
   end
 
   # A class definition
   #
   class HostClassDefinition < NamedDefinition
     has_attr 'parent_class', String
   end
 
   # i.e {|parameters| body }
   class LambdaExpression < Expression
     contains_many_uni 'parameters', Parameter
     contains_one_uni 'body', Expression
   end
 
   # If expression. If test is true, the then_expr part should be evaluated, else the (optional)
   # else_expr. An 'elsif' is simply an else_expr = IfExpression, and 'else' is simply else == Block.
   # a 'then' is typically a Block.
   #
   class IfExpression < Expression
     contains_one_uni 'test', Expression, :lowerBound => 1
     contains_one_uni 'then_expr', Expression, :lowerBound => 1
     contains_one_uni 'else_expr', Expression
   end
 
   # An if expression with boolean reversed test.
   #
   class UnlessExpression < IfExpression
   end
 
   # An abstract call.
   #
   class CallExpression < Expression
     abstract
     # A bit of a crutch; functions are either procedures (void return) or has an rvalue
     # this flag tells the evaluator that it is a failure to call a function that is void/procedure
     # where a value is expected.
     #
     has_attr 'rval_required', Boolean, :defaultValueLiteral => "false"
     contains_one_uni 'functor_expr', Expression, :lowerBound => 1
     contains_many_uni 'arguments', Expression
     contains_one_uni 'lambda', Expression
   end
 
   # A function call where the functor_expr should evaluate to something callable.
   #
   class CallFunctionExpression < CallExpression; end
 
   # A function call where the given functor_expr should evaluate to the name
   # of a function.
   #
   class CallNamedFunctionExpression < CallExpression; end
 
   # A method/function call where the function expr is a NamedAccess and with support for
   # an optional lambda block
   #
   class CallMethodExpression < CallExpression
   end
 
   # Abstract base class for literals.
   #
   class Literal < Expression
     abstract
   end
 
   # A literal value is an abstract value holder. The type of the contained value is
   # determined by the concrete subclass.
   #
   class LiteralValue < Literal
     abstract
   end
 
   # A Regular Expression Literal.
   #
   class LiteralRegularExpression < LiteralValue
     has_attr 'value', Object, :lowerBound => 1, :transient => true
     has_attr 'pattern', String, :lowerBound => 1
 
     module ClassModule
       # Go through the gymnastics of making either value or pattern settable
       # with synchronization to the other form. A derived value cannot be serialized
       # and we want to serialize the pattern. When recreating the object we need to
       # recreate it from the pattern string.
       # The below sets both values if one is changed.
       #
       def value= regexp
         setValue regexp
         setPattern regexp.to_s
       end
 
       def pattern= regexp_string
         setPattern regexp_string
         setValue Regexp.new(regexp_string)
       end
     end
 
   end
 
   # A Literal String
   #
   class LiteralString < LiteralValue
     has_attr 'value', String, :lowerBound => 1
   end
 
   class LiteralNumber < LiteralValue
     abstract
   end
 
   # A literal number has a radix of decimal (10), octal (8), or hex (16) to enable string conversion with the input radix.
   # By default, a radix of 10 is used.
   #
   class LiteralInteger < LiteralNumber
     has_attr 'radix', Integer, :lowerBound => 1, :defaultValueLiteral => "10"
     has_attr 'value', Integer, :lowerBound => 1
   end
 
   class LiteralFloat < LiteralNumber
     has_attr 'value', Float, :lowerBound => 1
   end
 
   # The DSL `undef`.
   #
   class LiteralUndef < Literal; end
 
   # The DSL `default`
   class LiteralDefault < Literal; end
 
   # DSL `true` or `false`
   class LiteralBoolean < LiteralValue
     has_attr 'value', Boolean, :lowerBound => 1
   end
 
   # A text expression is an interpolation of an expression. If the embedded expression is
   # a QualifiedName, it is taken as a variable name and resolved. All other expressions are evaluated.
   # The result is transformed to a string.
   #
   class TextExpression < UnaryExpression; end
 
   # An interpolated/concatenated string. The contained segments are expressions. Verbatim sections
   # should be LiteralString instances, and interpolated expressions should either be
   # TextExpression instances (if QualifiedNames should be turned into variables), or any other expression
   # if such treatment is not needed.
   #
   class ConcatenatedString < Expression
     contains_many_uni 'segments', Expression
   end
 
   # A DSL NAME (one or multiple parts separated by '::').
   #
   class QualifiedName < LiteralValue
     has_attr 'value', String, :lowerBound => 1
   end
 
   # A DSL CLASSREF (one or multiple parts separated by '::' where (at least) the first part starts with an upper case letter).
   #
   class QualifiedReference < LiteralValue
     has_attr 'value', String, :lowerBound => 1
   end
 
   # A Variable expression looks up value of expr (some kind of name) in scope.
   # The expression is typically a QualifiedName, or QualifiedReference.
   #
   class VariableExpression < UnaryExpression; end
 
   # Epp start
   class EppExpression < Definition
+    contains_many_uni 'parameters', Parameter
+    contains_one_uni 'body', Expression
   end
 
   # A string to render
   class RenderStringExpression < LiteralString
   end
 
   # An expression to evluate and render
   class RenderExpression < UnaryExpression
   end
 
   # A resource body describes one resource instance
   #
   class ResourceBody < Positioned
     contains_one_uni 'title', Expression
     contains_many_uni 'operations', AttributeOperation
   end
 
   # An abstract resource describes the form of the resource (regular, virtual or exported)
   # and adds convenience methods to ask if it is virtual or exported.
   # All derived classes may not support all forms, and these needs to be validated
   #
   class AbstractResource < Expression
     abstract
     has_attr 'form', RGen::MetamodelBuilder::DataTypes::Enum.new([:regular, :virtual, :exported ]), :lowerBound => 1, :defaultValueLiteral => "regular"
     has_attr 'virtual', Boolean, :derived => true
     has_attr 'exported', Boolean, :derived => true
 
     module ClassModule
       def virtual_derived
         form == :virtual || form == :exported
       end
 
       def exported_derived
         form == :exported
       end
     end
 
   end
 
   # A resource expression is used to instantiate one or many resource. Resources may optionally
   # be virtual or exported, an exported resource is always virtual.
   #
   class ResourceExpression < AbstractResource
     contains_one_uni 'type_name', Expression, :lowerBound => 1
     contains_many_uni 'bodies', ResourceBody
   end
 
   # A resource defaults sets defaults for a resource type. This class inherits from AbstractResource
   # but does only support the :regular form (this is intentional to be able to produce better error messages
   # when illegal forms are applied to a model.
   #
   class ResourceDefaultsExpression < AbstractResource
     contains_one_uni 'type_ref', QualifiedReference
     contains_many_uni 'operations', AttributeOperation
   end
 
   # A resource override overrides already set values.
   #
   class ResourceOverrideExpression < Expression
     contains_one_uni 'resources', Expression, :lowerBound => 1
     contains_many_uni 'operations', AttributeOperation
   end
 
   # A selector entry describes a map from matching_expr to value_expr.
   #
   class SelectorEntry < Positioned
     contains_one_uni 'matching_expr', Expression, :lowerBound => 1
     contains_one_uni 'value_expr', Expression, :lowerBound => 1
   end
 
   # A selector expression represents a mapping from a left_expr to a matching SelectorEntry.
   #
   class SelectorExpression < Expression
     contains_one_uni 'left_expr', Expression, :lowerBound => 1
     contains_many_uni 'selectors', SelectorEntry
   end
 
   # A named access expression looks up a named part. (e.g. $a.b)
   #
   class NamedAccessExpression < BinaryExpression; end
 
   # A Program is the top level construct returned by the parser
   # it contains the parsed result in the body, and has a reference to the full source text,
   # and its origin. The line_offset's is an array with the start offset of each line.
   #
   class Program < PopsObject
     contains_one_uni 'body', Expression
     has_many 'definitions', Definition
     has_attr 'source_text', String
     has_attr 'source_ref', String
     has_many_attr 'line_offsets', Integer
     has_attr 'locator', Object, :lowerBound => 1, :transient => true
 
     module ClassModule
       def locator
         unless result = getLocator
           setLocator(result = Puppet::Pops::Parser::Locator.locator(source_text, source_ref(), line_offsets))
         end
         result
       end
     end
 
   end
 end
diff --git a/lib/puppet/pops/parser/egrammar.ra b/lib/puppet/pops/parser/egrammar.ra
index 8f2a82e16..b9ee391ef 100644
--- a/lib/puppet/pops/parser/egrammar.ra
+++ b/lib/puppet/pops/parser/egrammar.ra
@@ -1,743 +1,743 @@
 # vim: syntax=ruby
 
 # Parser using the Pops model, expression based
 
 class Puppet::Pops::Parser::Parser
 
 token STRING DQPRE DQMID DQPOST
 token LBRACK  RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
 token FALSE EQUALS APPENDS DELETES LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
 token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
 token IF ELSE
 token DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
 token NAME SEMIC CASE DEFAULT AT ATAT LCOLLECT RCOLLECT CLASSREF
 token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
 token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
 token IN UNLESS PIPE
 token LAMBDA SELBRACE
 token NUMBER
 token HEREDOC SUBLOCATE
 token RENDER_STRING RENDER_EXPR EPP_START
 token LOW
 
 prechigh
   left  HIGH
   left  SEMIC
   left  PIPE
   left  LPAREN
   left  RPAREN
   left  AT ATAT
   left  DOT
   left  CALL
   nonassoc EPP_START
   left  LBRACK LISTSTART
   left  RBRACK
   left  QMARK
   left  LCOLLECT LLCOLLECT
   right NOT
   nonassoc UMINUS
   left  IN
   left  MATCH NOMATCH
   left  TIMES DIV MODULO
   left  MINUS PLUS
   left  LSHIFT RSHIFT
   left  NOTEQUAL ISEQUAL
   left  GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
   left  AND
   left  OR
   right APPENDS DELETES EQUALS
   left  LBRACE
   left  SELBRACE
   left  RBRACE
   left  IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
   left  TITLE_COLON
   left  CASE_COLON
   left  FARROW
   left  COMMA
   nonassoc RENDER_EXPR
   nonassoc RENDER_STRING
   left  LOW
 preclow
 
 rule
 # Produces [Model::BlockExpression, Model::Expression, nil] depending on multiple statements, single statement or empty
 program
   : statements { result = create_program(Factory.block_or_expression(*val[0])) }
-  | epp_expression { result = Factory.block_or_expression(*val[0]) }
+  | epp_expression { result = create_program(Factory.block_or_expression(*val[0])) }
   | nil
 
 # Produces a semantic model (non validated, but semantically adjusted).
 statements
   : syntactic_statements { result = transform_calls(val[0]) }
 
 # Change may have issues with nil; i.e. program is a sequence of nils/nops
 # Simplified from original which had validation for top level constructs - see statement rule
 # Produces Array<Model::Expression>
 syntactic_statements
   : syntactic_statement                            { result = [val[0]]}
   | syntactic_statements SEMIC syntactic_statement { result = val[0].push val[2] }
   | syntactic_statements syntactic_statement       { result = val[0].push val[1] }
 
 # Produce a single expression or Array of expression
 syntactic_statement
   : any_expression                            { result = val[0] }
   | syntactic_statement COMMA any_expression  { result = aryfy(val[0]).push val[2] }
 
 any_expression
   : relationship_expression
 
 relationship_expression
   : resource_expression                                     =LOW  { result = val[0] }
   | relationship_expression IN_EDGE      relationship_expression  { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
   | relationship_expression IN_EDGE_SUB  relationship_expression  { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
   | relationship_expression OUT_EDGE     relationship_expression  { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
   | relationship_expression OUT_EDGE_SUB relationship_expression  { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
 
 #---EXPRESSION
 #
 # Produces Model::Expression
 expression
   : higher_precedence
   | expression LBRACK       expressions RBRACK =LBRACK { result = val[0][*val[2]]         ; loc result, val[0], val[3] }
   | expression IN           expression                 { result = val[0].in val[2]        ; loc result, val[1] }
   | expression MATCH        expression                 { result = val[0] =~  val[2]       ; loc result, val[1] }
   | expression NOMATCH      expression                 { result = val[0].mne val[2]       ; loc result, val[1] }
   | expression PLUS         expression                 { result = val[0] +   val[2]       ; loc result, val[1] }
   | expression MINUS        expression                 { result = val[0] -   val[2]       ; loc result, val[1] }
   | expression DIV          expression                 { result = val[0] /   val[2]       ; loc result, val[1] }
   | expression TIMES        expression                 { result = val[0] *   val[2]       ; loc result, val[1] }
   | expression MODULO       expression                 { result = val[0] %   val[2]       ; loc result, val[1] }
   | expression LSHIFT       expression                 { result = val[0] <<  val[2]       ; loc result, val[1] }
   | expression RSHIFT       expression                 { result = val[0] >>  val[2]       ; loc result, val[1] }
   |            MINUS        expression         =UMINUS { result = val[1].minus()          ; loc result, val[0] }
   | expression NOTEQUAL     expression                 { result = val[0].ne  val[2]       ; loc result, val[1] }
   | expression ISEQUAL      expression                 { result = val[0] ==  val[2]       ; loc result, val[1] }
   | expression GREATERTHAN  expression                 { result = val[0] >   val[2]       ; loc result, val[1] }
   | expression GREATEREQUAL expression                 { result = val[0] >=  val[2]       ; loc result, val[1] }
   | expression LESSTHAN     expression                 { result = val[0] <   val[2]       ; loc result, val[1] }
   | expression LESSEQUAL    expression                 { result = val[0] <=  val[2]       ; loc result, val[1] }
   |            NOT          expression                 { result = val[1].not              ; loc result, val[0] }
   | expression AND          expression                 { result = val[0].and val[2]       ; loc result, val[1] }
   | expression OR           expression                 { result = val[0].or  val[2]       ; loc result, val[1] }
   | expression EQUALS       expression                 { result = val[0].set(val[2])      ; loc result, val[1] }
   | expression APPENDS      expression                 { result = val[0].plus_set(val[2]) ; loc result, val[1] }
   | expression DELETES      expression                 { result = val[0].minus_set(val[2]); loc result, val[1] }
   | expression QMARK selector_entries                  { result = val[0].select(*val[2])  ; loc result, val[0] }
   |            LPAREN       expression RPAREN          { result = val[1].paren()          ; loc result, val[0] }
 
 #---EXPRESSIONS
 #   (e.g. argument list)
 #
 # This expression list can not contain function calls without parentheses around arguments
 # Produces Array<Model::Expression>
 expressions
   : expression                   { result = [val[0]] }
   | expressions COMMA expression { result = val[0].push(val[2]) }
 
 # These go through a chain of left recursion, ending with primary_expression
 higher_precedence
   : call_function_expression
 
 primary_expression
   : literal_expression
   | variable
   | call_method_with_lambda_expression
   | collection_expression
   | case_expression
   | if_expression
   | unless_expression
   | definition_expression
   | hostclass_expression
   | node_definition_expression
   | epp_render_expression
 
 # Aleways have the same value
 literal_expression
   : array
   | boolean
   | default
   | hash
   | regex
   | text_or_name
   | number
   | type
   | undef
 
 text_or_name
   : name       { result = val[0] }
   | quotedtext { result = val[0] }
 
 #---CALL FUNCTION
 #
 # Produces Model::CallNamedFunction
 
 call_function_expression
   : primary_expression LPAREN expressions endcomma RPAREN {
       result = Factory.CALL_NAMED(val[0], true, val[2])
       loc result, val[0], val[4]
     }
   | primary_expression LPAREN RPAREN {
       result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
     }
   | primary_expression LPAREN expressions endcomma RPAREN lambda {
       result = Factory.CALL_NAMED(val[0], true, val[2])
       loc result, val[0], val[4]
       result.lambda = val[5]
     }
   | primary_expression LPAREN RPAREN  lambda {
       result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
       result.lambda = val[3]
     }
   | primary_expression = LOW { result = val[0] }
 
 #---CALL METHOD
 #
 call_method_with_lambda_expression
   : call_method_expression         =LOW { result = val[0] }
   | call_method_expression lambda  { result = val[0]; val[0].lambda = val[1] }
 
   call_method_expression
     : named_access LPAREN expressions RPAREN { result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] }
     | named_access LPAREN RPAREN             { result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3] }
     | named_access =LOW                      { result = Factory.CALL_METHOD(val[0], []); loc result, val[0] }
 
   # TODO: It may be of value to access named elements of types too
   named_access
     : expression DOT NAME {
         result = val[0].dot(Factory.fqn(val[2][:value]))
         loc result, val[1], val[2]
       }
 
 #---LAMBDA
 #
 # This is a temporary switch while experimenting with concrete syntax
 # One should be picked for inclusion in puppet.
 
 # Lambda with parameters to the left of the body
 lambda
   : lambda_parameter_list lambda_rest {
       result = Factory.LAMBDA(val[0], val[1])
 #      loc result, val[1] # TODO
     }
 
 lambda_rest
   : LBRACE statements RBRACE { result = val[1] }
   | LBRACE RBRACE { result = nil }
 
 # Produces Array<Model::Parameter>
 lambda_parameter_list
 : PIPE PIPE                     { result = [] }
 | PIPE parameters endcomma PIPE { result = val[1] }
 
 #---CONDITIONALS
 #
 
 #--IF
 #
 # Produces Model::IfExpression
 if_expression
   : IF if_part {
       result = val[1]
       loc(result, val[0], val[1])
     }
 
   # Produces Model::IfExpression
   if_part
     : expression LBRACE statements RBRACE else {
         result = Factory.IF(val[0], Factory.block_or_expression(*val[2]), val[4])
         loc(result, val[0], (val[4] ? val[4] : val[3]))
       }
     | expression LBRACE RBRACE else {
         result = Factory.IF(val[0], nil, val[3])
         loc(result, val[0], (val[3] ? val[3] : val[2]))
       }
 
   # Produces [Model::Expression, nil] - nil if there is no else or elsif part
   else
     : # nothing
     | ELSIF if_part {
         result = val[1]
         loc(result, val[0], val[1])
       }
     | ELSE LBRACE statements RBRACE {
         result = Factory.block_or_expression(*val[2])
         loc result, val[0], val[3]
       }
     | ELSE LBRACE RBRACE {
         result = nil # don't think a nop is needed here either
       }
 
 #--UNLESS
 #
 # Changed from Puppet 3x where there is no else part on unless
 #
 unless_expression
   : UNLESS expression LBRACE statements RBRACE unless_else {
       result = Factory.UNLESS(val[1], Factory.block_or_expression(*val[3]), val[5])
       loc result, val[0], val[4]
     }
   | UNLESS expression LBRACE RBRACE unless_else {
       result = Factory.UNLESS(val[1], nil, nil)
       loc result, val[0], val[4]
     }
 
   # Different from else part of if, since "elsif" is not supported, but 'else' is
   #
   # Produces [Model::Expression, nil] - nil if there is no else or elsif part
   unless_else
     : # nothing
     | ELSE LBRACE statements RBRACE {
         result = Factory.block_or_expression(*val[2])
         loc result, val[0], val[3]
       }
     | ELSE LBRACE RBRACE {
         result = nil # don't think a nop is needed here either
       }
 
 #--- CASE EXPRESSION
 #
 # Produces Model::CaseExpression
 case_expression
   : CASE expression LBRACE case_options RBRACE {
       result = Factory.CASE(val[1], *val[3])
       loc result, val[0], val[4]
     }
 
   # Produces Array<Model::CaseOption>
   case_options
     : case_option               { result = [val[0]] }
     | case_options case_option { result = val[0].push val[1] }
 
   # Produced Model::CaseOption (aka When)
   case_option
     : expressions case_colon LBRACE statements RBRACE {
         result = Factory.WHEN(val[0], val[3])
         loc result, val[1], val[4]
       }
     | expressions case_colon LBRACE RBRACE = LOW {
         result = Factory.WHEN(val[0], nil)
         loc result, val[1], val[3]
       }
 
   case_colon: COLON =CASE_COLON { result = val[0] }
 
   # This special construct is required or racc will produce the wrong result when the selector entry
   # LHS is generalized to any expression (LBRACE looks like a hash). Thus it is not possible to write
   # a selector with a single entry where the entry LHS is a hash.
   # The SELBRACE token is a LBRACE that follows a QMARK, and this is produced by the lexer with a lookback
   # Produces Array<Model::SelectorEntry>
   #
   selector_entries
     : selector_entry
     | SELBRACE selector_entry_list endcomma RBRACE {
         result = val[1]
       }
 
   # Produces Array<Model::SelectorEntry>
   selector_entry_list
     : selector_entry                           { result = [val[0]] }
     | selector_entry_list COMMA selector_entry { result = val[0].push val[2] }
 
   # Produces a Model::SelectorEntry
   # This FARROW wins over FARROW in Hash
   selector_entry
     : expression FARROW expression { result = Factory.MAP(val[0], val[2]) ; loc result, val[1] }
 
 #---RESOURCE
 #
 # Produces [Model::ResourceExpression, Model::ResourceDefaultsExpression]
 
 # The resource expression parses a generalized syntax and then selects the correct
 # resulting model based on the combinatoin of the LHS and what follows.
 # It also handled exported and virtual resources, and the class case
 #
 resource_expression
   : expression =LOW {
       result = val[0]
     }
   | at expression LBRACE resourceinstances endsemi RBRACE {
       result = case Factory.resource_shape(val[1])
       when :resource, :class
         tmp = Factory.RESOURCE(Factory.fqn(token_text(val[1])), val[3])
         tmp.form = val[0]
         tmp
       when :defaults
         error val[1], "A resource default can not be virtual or exported"
       when :override
         error val[1], "A resource override can not be virtual or exported"
       else
         error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[1], val[4]
     }
   | at expression LBRACE attribute_operations endcomma RBRACE {
       result = case Factory.resource_shape(val[1])
       when :resource, :class, :defaults, :override
         error val[1], "Defaults are not virtualizable"
       else
         error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
     }
   | expression LBRACE resourceinstances endsemi RBRACE {
       result = case Factory.resource_shape(val[0])
       when :resource, :class
         Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
       when :defaults
         error val[1], "A resource default can not specify a resource name"
       when :override
         error val[1], "A resource override does not allow override of name of resource"
       else
         error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[0], val[4]
     }
   | expression LBRACE attribute_operations endcomma RBRACE {
       result = case Factory.resource_shape(val[0])
       when :resource, :class
         # This catches deprecated syntax.
         error val[1], "All resource specifications require names"
       when :defaults
         Factory.RESOURCE_DEFAULTS(val[0], val[2])
       when :override
         # This was only done for override in original - TODO shuld it be here at all
         Factory.RESOURCE_OVERRIDE(val[0], val[2])
       else
         error val[0], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[0], val[4]
     }
   | at CLASS LBRACE resourceinstances endsemi RBRACE {
         result = Factory.RESOURCE(Factory.fqn(token_text(val[1])), val[3])
         result.form = val[0]
         loc result, val[1], val[5]
     }
   | CLASS LBRACE resourceinstances endsemi RBRACE {
         result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
         loc result, val[0], val[4]
     }
 
   resourceinst
     : expression title_colon attribute_operations endcomma { result = Factory.RESOURCE_BODY(val[0], val[2]) }
 
   title_colon : COLON =TITLE_COLON { result = val[0] }
 
   resourceinstances
     : resourceinst                         { result = [val[0]] }
     | resourceinstances SEMIC resourceinst { result = val[0].push val[2] }
 
   # Produces Symbol corresponding to resource form
   #
   at
     : AT    { result = :virtual  }
     | AT AT { result = :exported }
     | ATAT  { result = :exported }
 
 #---COLLECTION
 #
 # A Collection is a predicate applied to a set of objects with an implied context (used variables are
 # attributes of the object.
 # i.e. this is equivalent for source.select(QUERY).apply(ATTRIBUTE_OPERATIONS)
 #
 # Produces Model::CollectExpression
 #
 collection_expression
   : expression collect_query LBRACE attribute_operations endcomma RBRACE {
       result = Factory.COLLECT(val[0], val[1], val[3])
       loc result, val[0], val[5]
     }
   | expression collect_query =LOW {
       result = Factory.COLLECT(val[0], val[1], [])
       loc result, val[0], val[1]
     }
 
   collect_query
     : LCOLLECT  optional_query RCOLLECT  { result = Factory.VIRTUAL_QUERY(val[1])   ; loc result, val[0], val[2] }
     | LLCOLLECT optional_query RRCOLLECT { result = Factory.EXPORTED_QUERY(val[1])  ; loc result, val[0], val[2] }
 
   optional_query
     : nil
     | expression
 
 #---ATTRIBUTE OPERATIONS
 #
 # (Not an expression)
 #
 # Produces Array<Model::AttributeOperation>
 #
 attribute_operations
   :                                                { result = [] }
   | attribute_operation                            { result = [val[0]] }
   | attribute_operations COMMA attribute_operation { result = val[0].push(val[2]) }
 
   # Produces String
   # QUESTION: Why is BOOLEAN valid as an attribute name?
   #
   attribute_name
     : NAME
     | keyword
     | BOOLEAN
 
   # In this version, illegal combinations are validated instead of producing syntax errors
   # (Can give nicer error message "+> is not applicable to...")
   # Produces Model::AttributeOperation
   #
   attribute_operation
     : attribute_name FARROW expression {
         result = Factory.ATTRIBUTE_OP(val[0][:value], :'=>', val[2])
         loc result, val[0], val[2]
       }
     | attribute_name PARROW expression {
         result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
         loc result, val[0], val[2]
       }
 
 #---DEFINE
 #
 # Produces Model::Definition
 #
 definition_expression
   : DEFINE classname parameter_list LBRACE opt_statements RBRACE {
       result = add_definition(Factory.DEFINITION(classname(val[1][:value]), val[2], val[4]))
       loc result, val[0], val[5]
       # New lexer does not keep track of this, this is done in validation
       if @lexer.respond_to?(:'indefine=')
         @lexer.indefine = false
       end
     }
 
 #---HOSTCLASS
 #
 # Produces Model::HostClassDefinition
 #
 hostclass_expression
   : CLASS stacked_classname parameter_list classparent LBRACE opt_statements RBRACE {
       # Remove this class' name from the namestack as all nested classes have been parsed
       namepop
       result = add_definition(Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5]))
       loc result, val[0], val[6]
     }
 
   # Record the classname so nested classes gets a fully qualified name at parse-time
   # This is a separate rule since racc does not support intermediate actions.
   #
   stacked_classname
     : classname { namestack(val[0][:value]) ; result = val[0] }
 
   opt_statements
     : statements
     | nil
 
   # Produces String, name or nil result
   classparent
     : nil
     | INHERITS classnameordefault { result = val[1] }
 
   # Produces String (this construct allows a class to be named "default" and to be referenced as
   # the parent class.
   # TODO: Investigate the validity
   # Produces a String (classname), or a token (DEFAULT).
   #
   classnameordefault
     : classname
     | DEFAULT
 
 #---NODE
 #
 # Produces Model::NodeDefinition
 #
 node_definition_expression
   : NODE hostnames nodeparent LBRACE statements RBRACE {
       result = add_definition(Factory.NODE(val[1], val[2], val[4]))
       loc result, val[0], val[5]
     }
   | NODE hostnames nodeparent LBRACE RBRACE {
       result = add_definition(Factory.NODE(val[1], val[2], nil))
       loc result, val[0], val[4]
     }
 
   # Hostnames is not a list of names, it is a list of name matchers (including a Regexp).
   # (The old implementation had a special "Hostname" object with some minimal validation)
   #
   # Produces Array<Model::LiteralExpression>
   #
   hostnames
     : hostname                 { result = [result] }
     | hostnames COMMA hostname { result = val[0].push(val[2]) }
 
   # Produces a LiteralExpression (string, :default, or regexp)
   # String with interpolation is validated for better error message
   hostname
     : dotted_name { result = val[0] }
     | quotedtext  { result = val[0] }
     | DEFAULT     { result = Factory.literal(:default); loc result, val[0] }
     | regex
 
   dotted_name
     : NAME        { result = Factory.literal(val[0][:value]); loc result, val[0] }
     | dotted_name DOT NAME { result = Factory.concat(val[0], '.', val[2][:value]); loc result, val[0], val[2] }
 
   # Produces Expression, since hostname is an Expression
   nodeparent
     : nil
     | INHERITS hostname { result = val[1] }
 
 #---NAMES AND PARAMETERS COMMON TO SEVERAL RULES
 #   Produces String
 #
 classname
   : NAME  { result = val[0] }
   | CLASS { error val[0], "'class' is not a valid classname" }
 
 # Produces Array<Model::Parameter>
 parameter_list
   : nil                               { result = [] }
   | LPAREN  RPAREN                    { result = [] }
   | LPAREN parameters endcomma RPAREN { result = val[1] }
 
 # Produces Array<Model::Parameter>
 parameters
   : parameter                  { result = [val[0]] }
   | parameters COMMA parameter { result = val[0].push(val[2]) }
 
 # Produces Model::Parameter
 parameter
   : VARIABLE EQUALS expression { result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0] }
   | VARIABLE                   { result = Factory.PARAM(val[0][:value]); loc result, val[0] }
 
 #--RESTRICTED EXPRESSIONS
 #  i.e. where one could have expected an expression, but the set is limited
 
 ## What is allowed RHS of match operators (see expression)
 #match_rvalue
 #  : regex
 #  | text_or_name
 
 #--VARIABLE
 #
 variable
   : VARIABLE { result = Factory.fqn(val[0][:value]).var ; loc result, val[0] }
 
 #---LITERALS (dynamic and static)
 #
 
 array
   : LBRACK expressions       RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[2] }
   | LBRACK expressions COMMA RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
   | LBRACK                   RBRACK { result = Factory.literal([]) ; loc result, val[0] }
   | LISTSTART expressions       RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[2] }
   | LISTSTART expressions COMMA RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
   | LISTSTART                   RBRACK { result = Factory.literal([]) ; loc result, val[0] }
 
 hash
   : LBRACE hashpairs RBRACE       { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
   | LBRACE hashpairs COMMA RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[3] }
   | LBRACE RBRACE                 { result = Factory.literal({}) ; loc result, val[0], val[3] }
 
   hashpairs
     : hashpair                 { result = [val[0]] }
     | hashpairs COMMA hashpair { result = val[0].push val[2] }
 
   hashpair
     : expression FARROW expression { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
 
 quotedtext
   : string
   | dq_string
   | heredoc
 
 string          : STRING                 { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
 dq_string       : dqpre dqrval           { result = Factory.string(val[0], *val[1]) ; loc result, val[0], val[1][-1] }
 dqpre           : DQPRE                  { result = Factory.literal(val[0][:value]); loc result, val[0] }
 dqpost          : DQPOST                 { result = Factory.literal(val[0][:value]); loc result, val[0] }
 dqmid           : DQMID                  { result = Factory.literal(val[0][:value]); loc result, val[0] }
 dqrval          : text_expression dqtail { result = [val[0]] + val[1] }
 text_expression : expression             { result = Factory.TEXT(val[0]) }
 
 dqtail
   : dqpost        { result = [val[0]] }
   | dqmid dqrval  { result = [val[0]] + val[1] }
 
 # TODO_HEREDOC
 heredoc
   : HEREDOC sublocated_text  { result = Factory.HEREDOC(val[0][:value], val[1]); loc result, val[0] }
 
 sublocated_text
   : SUBLOCATE string    { result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] }
   | SUBLOCATE dq_string { result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] }
 
 # TODO_EPP
 epp_expression
   : EPP_START epp_parameters_list statements { result = Factory.EPP(val[1], val[2]); loc result, val[0] }
 
 epp_parameters_list
   :                                  =LOW{ result = [] }
   | LPAREN RPAREN                        { result = [] }
   | LPAREN parameters endcomma RPAREN    { result = val[1] }
 
 epp_render_expression
   : RENDER_STRING          { result = Factory.RENDER_STRING(val[0][:value]); loc result, val[0] }
   | RENDER_EXPR expression { result = Factory.RENDER_EXPR(val[1]); loc result, val[0], val[1] }
 
 number   : NUMBER   { result = Factory.NUMBER(val[0][:value]) ; loc result, val[0] }
 name     : NAME     { result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] }
 type     : CLASSREF { result = Factory.QREF(val[0][:value])  ; loc result, val[0] }
 undef    : UNDEF    { result = Factory.literal(:undef); loc result, val[0] }
 default  : DEFAULT  { result = Factory.literal(:default); loc result, val[0] }
 
           # Assumes lexer produces a Boolean value for booleans, or this will go wrong and produce a literal string
           # with the text 'true'.
           #TODO: could be changed to a specific boolean literal factory method to prevent this possible glitch.
 boolean  : BOOLEAN { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
 
 regex
   : REGEX { result = Factory.literal(val[0][:value]); loc result, val[0] }
 
 #---MARKERS, SPECIAL TOKENS, SYNTACTIC SUGAR, etc.
 
 endcomma
   : #
   | COMMA { result = nil }
 
 endsemi
   : #
   | SEMIC
 
 keyword
  : AND
  | CASE
  | CLASS
  | DEFAULT
  | DEFINE
  | ELSE
  | ELSIF
  | IF
  | IN
  | INHERITS
  | NODE
  | OR
  | UNDEF
  | UNLESS
 
 nil
   : { result = nil}
 
 end
 
 ---- header ----
 require 'puppet'
 require 'puppet/pops'
 
 module Puppet
   class ParseError < Puppet::Error; end
   class ImportError < Racc::ParseError; end
   class AlreadyImportedError < ImportError; end
 end
 
 ---- inner ----
 
 # Make emacs happy
 # Local Variables:
 # mode: ruby
 # End:
diff --git a/lib/puppet/pops/parser/eparser.rb b/lib/puppet/pops/parser/eparser.rb
index 47e5bd0a7..452c3eda6 100644
--- a/lib/puppet/pops/parser/eparser.rb
+++ b/lib/puppet/pops/parser/eparser.rb
@@ -1,2541 +1,2541 @@
 #
 # DO NOT MODIFY!!!!
 # This file is automatically generated by Racc 1.4.9
 # from Racc grammer file "".
 #
 
 require 'racc/parser.rb'
 
 require 'puppet'
 require 'puppet/pops'
 
 module Puppet
   class ParseError < Puppet::Error; end
   class ImportError < Racc::ParseError; end
   class AlreadyImportedError < ImportError; end
 end
 
 module Puppet
   module Pops
     module Parser
       class Parser < Racc::Parser
 
 module_eval(<<'...end egrammar.ra/module_eval...', 'egrammar.ra', 739)
 
 # Make emacs happy
 # Local Variables:
 # mode: ruby
 # End:
 ...end egrammar.ra/module_eval...
 ##### State transition tables begin ###
 
 clist = [
 '57,59,-132,269,51,259,53,-130,79,-213,-222,126,259,126,79,125,257,125',
 '307,292,223,346,102,14,106,223,101,223,102,41,106,48,101,50,45,234,49',
 '69,65,237,43,68,46,47,-132,270,66,13,105,-130,67,-213,-222,12,105,220',
 '57,59,249,248,51,70,53,387,239,126,234,42,79,125,80,64,60,122,62,63',
 '61,126,242,14,52,125,102,241,106,41,101,48,246,50,45,247,49,69,65,290',
 '43,68,46,47,126,126,66,13,125,125,67,356,105,12,57,59,240,244,51,258',
 '53,70,243,341,259,340,313,42,79,324,230,64,60,310,62,63,341,14,340,326',
 '52,219,102,41,106,48,101,50,45,328,49,69,65,72,43,68,46,47,126,309,66',
 '13,125,306,67,57,59,12,105,266,57,59,268,291,51,70,53,385,86,85,333',
 '42,79,81,82,64,60,334,62,63,80,335,223,14,52,210,102,338,106,41,101',
 '48,290,50,45,87,49,69,65,342,43,68,46,47,344,74,66,13,186,266,67,268',
 '105,12,266,352,57,59,353,114,51,70,53,383,290,74,153,42,151,149,363',
 '64,60,284,62,63,364,57,59,14,52,57,59,283,268,41,127,48,282,50,45,367',
 '49,69,65,114,43,68,46,47,115,268,66,13,114,371,67,344,373,12,57,59,374',
 '375,51,135,53,70,133,135,376,377,133,42,111,379,380,64,60,381,62,63',
 '266,14,74,71,52,388,70,41,389,48,70,50,108,390,49,69,65,60,43,68,391',
 '60,,,66,13,,,67,,,12,57,59,,,51,,53,70,75,77,76,78,,42,,,,64,60,,62',
 '63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57',
 '59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49',
 '69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60',
 ',62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12',
 '57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,45,',
 '49,69,65,,43,68,46,47,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,',
 ',64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,',
 ',67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48',
 ',50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,',
 '42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66',
 '13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41',
 ',48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,',
 ',,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,',
 ',,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52',
 ',,41,,48,,50,121,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53',
 '70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68',
 ',,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,',
 '52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51',
 ',53,70,,,,,,42,79,,,64,60,,62,63,,14,,,52,,102,41,106,48,101,50,108',
 ',49,69,65,,43,68,,,,,66,13,,,67,,,12,105,,57,59,,,51,70,53,288,86,85',
 ',42,,81,82,64,60,,62,63,80,,,14,52,57,59,,,41,,48,,50,45,87,49,69,65',
 ',43,68,46,47,,,66,13,,,67,,,12,57,59,,,51,138,53,70,,135,,,133,42,,',
 ',64,60,,62,63,,14,,,52,,,41,,48,70,50,108,,49,69,65,,43,68,,60,,,66',
 '13,57,59,67,,,12,57,59,,,51,140,53,70,,,,,,42,,,,64,60,,62,63,,14,,',
 '52,,,41,,48,135,50,108,133,49,69,65,,43,68,,,,,66,13,,,67,,,12,,70,57',
 '59,,,51,70,53,143,,,60,42,,,,64,60,,62,63,,,,14,52,,,,,41,,48,,50,108',
 ',49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,79,,',
 '64,60,,62,63,,14,,,52,,102,41,106,48,101,50,108,,49,69,65,,43,68,,,',
 ',66,13,,,67,,,12,105,,57,59,,,51,70,53,294,,,,42,,81,82,64,60,,62,63',
 '80,,,14,52,,,,,41,,48,,50,45,,49,69,65,,43,68,46,47,,,66,13,,,67,,,12',
 '57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,45,',
 '49,69,65,,43,68,46,47,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,79',
 ',,64,60,,62,63,,14,,,52,,102,41,106,48,101,50,108,,49,69,65,,43,68,',
 ',,,66,13,,,67,,,12,105,,57,59,,,51,70,53,362,,,,42,,,,64,60,,62,63,80',
 ',,14,52,,,,,41,,48,,50,45,,49,69,65,,43,68,46,47,,,66,13,,,67,,,12,57',
 '59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,45,,49',
 '69,65,,43,68,46,47,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64',
 '60,,62,63,,14,,,52,,,41,,48,,50,45,,49,69,65,,43,68,46,47,,,66,13,,',
 '67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48',
 ',50,45,,49,69,65,,43,68,46,47,,,66,13,,,67,,,12,57,59,,,51,,53,70,,',
 ',,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,45,,49,69,65,,43,68,46,47',
 ',,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52',
 ',,41,,48,,50,45,,49,69,65,,43,68,46,47,,,66,13,,,67,,,12,57,59,,,51',
 ',53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,45,,49,69,65,,43',
 '68,46,47,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63',
 ',14,,,52,,,41,,48,,50,45,,49,69,65,,43,68,46,47,,,66,13,,,67,,,12,57',
 '59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49',
 '69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60',
 ',62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12',
 '57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108',
 ',49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64',
 '60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67',
 ',,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50',
 '108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,',
 ',,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13',
 ',,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48',
 ',50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,',
 '42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66',
 '13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41',
 ',48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,',
 ',,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,',
 ',,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52',
 ',,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53',
 '70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68',
 ',,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,',
 '52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51',
 ',53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,',
 '43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63',
 ',14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59',
 ',,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69',
 '65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62',
 '63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57',
 '59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49',
 '69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60',
 ',62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12',
 '57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108',
 ',49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64',
 '60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67',
 ',,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50',
 '108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,',
 ',,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13',
 ',,67,,,12,,,57,59,,,51,70,53,347,,,,42,,,185,64,60,,62,63,,,,14,52,',
 ',,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53',
 '70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,188,205,199,206,50,200,208,201',
 '197,195,,190,203,,,,,66,13,209,204,202,,,12,57,59,,,51,,53,70,,,,,207',
 '189,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66',
 '13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41',
 ',48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,',
 ',,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,',
 ',,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52',
 ',,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53',
 '70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68',
 ',,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,79,,,64,60,,62,63,,14',
 ',,52,,102,41,106,48,101,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12',
 '105,,57,59,,,51,70,53,296,,,,42,,81,82,64,60,,62,63,80,,,14,52,,,,,41',
 ',48,,50,45,,49,69,65,,43,68,46,47,,,66,13,,,67,,,12,57,59,,,51,,53,70',
 ',,,,,42,,,,64,60,,62,63,,14,217,,52,,,41,,48,,50,108,,49,69,65,,43,68',
 ',,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,',
 '52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51',
 ',53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,',
 '43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63',
 ',14,225,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57',
 '59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49',
 '69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,316,53,70,,,,,,42,,,,64',
 '60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67',
 ',,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50',
 '108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,315,53,70,,,,,,42',
 ',,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13',
 ',,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,41,,48',
 ',50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,',
 '42,,,,64,60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66',
 '13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,79,,,64,60,,62,63,,14,,,52,,102',
 '41,106,48,101,50,108,,49,69,65,,43,68,,,,,66,13,,,67,,,12,105,,57,59',
 ',,51,70,53,318,,,,42,,81,82,64,60,,62,63,80,,,14,52,,,,,41,,48,,50,108',
 ',49,69,65,,43,68,,,,,66,13,,,67,,,12,57,59,,,51,,53,70,,,,,,42,,,,64',
 '60,,62,63,,14,,,52,,,41,,48,,50,108,,49,69,65,,43,68,,,,,66,13,,,67',
 ',,12,57,59,,,51,,53,70,,,,,,42,,,,64,60,,62,63,,14,,,52,,,188,205,199',
 '206,50,200,208,201,197,195,,190,203,,,,,66,13,209,204,202,,,12,,,,,',
 ',,70,,,,,207,189,,,,64,60,79,62,63,,,,,52,,98,99,100,95,90,102,,106',
 ',101,,,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,',
 '81,82,79,,229,,,80,,,,98,99,100,95,90,102,,106,,101,,87,91,93,92,94',
 ',,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82,79,,228,,,80',
 ',,,98,99,100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,,,,,,,,,,,105',
 ',,,97,96,,,83,84,86,85,88,89,,81,82,,79,,,,80,245,,,,98,99,100,95,90',
 '102,,106,,101,87,,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86',
 '85,88,89,,81,82,79,,227,,,80,,,,98,99,100,95,90,102,,106,,101,,87,91',
 '93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82,79,',
 ',,,80,,,,98,99,100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,,,,,,,,',
 ',,105,,,,97,96,,,83,84,86,85,88,89,,81,82,79,,226,,,80,,,,98,99,100',
 '95,90,102,,106,,101,,87,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83',
 '84,86,85,88,89,,81,82,,79,,,,80,,,,,98,99,100,95,90,102,,106,,101,87',
 '215,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81',
 '82,79,,,,,80,,,,98,99,100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,',
 ',,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82,79,,,,,80,,,,98,99',
 '100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96',
 ',,83,84,86,85,88,89,,81,82,79,,,,,80,,,,98,99,100,95,90,102,,106,,101',
 ',87,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81',
 '82,79,,,,,80,,,,98,99,100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,',
 ',,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82,79,,,,,80,,,,98,99',
 '100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96',
 ',,83,84,86,85,88,89,,81,82,79,,,,,80,,,,98,99,100,95,90,102,,106,,101',
 ',87,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81',
 '82,79,,,,,80,,,,98,99,100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,',
 ',,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82,79,,,,,80,,,,98,99',
 '100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96',
 ',,83,84,86,85,88,89,,81,82,79,,,,,80,,,,98,99,100,95,90,102,264,106',
 ',101,,87,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89',
 ',81,82,79,,103,,,80,,,,98,99,100,95,90,102,,106,,101,,87,91,93,92,94',
 ',,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82,,79,,,,80,260',
 ',,,98,99,100,95,90,102,,106,79,101,87,,91,93,92,94,,,,,,,102,,106,,101',
 ',,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82,105,,,79,,80,,,83,84,86',
 '85,,,,81,82,102,,106,87,101,80,,,,79,,,,,,,,,,,87,,,102,,106,105,101',
 ',79,,,,,83,84,86,85,,,,81,82,102,,106,,101,80,105,,,,,,,,83,84,86,85',
 '88,89,87,81,82,,,,105,,80,,,79,,,83,84,86,85,88,89,,81,82,87,90,102',
 ',106,80,101,,79,91,,,,,,,,,,,87,90,102,,106,,101,,105,91,,,,,,,83,84',
 '86,85,88,89,,81,82,,,,105,,80,,,79,,,83,84,86,85,88,89,,81,82,87,90',
 '102,,106,80,101,,79,91,,,,,,,,,,,87,90,102,,106,,101,,105,91,,,,,,,83',
 '84,86,85,88,89,,81,82,,,,105,,80,,,,,79,83,84,86,85,88,89,,81,82,87',
 ',95,90,102,80,106,,101,,79,91,93,92,94,,,,,,87,,95,90,102,,106,,101',
 ',105,91,93,92,94,,,,83,84,86,85,88,89,,81,82,,,,105,,80,,,96,,,83,84',
 '86,85,88,89,,81,82,87,79,,,,80,,,,,98,99,100,95,90,102,,106,,101,87',
 ',91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82',
 '79,,,,,80,,,,98,99,100,95,90,102,,106,,101,,87,91,93,92,94,,,,,,,,,',
 ',,,,,,105,,,,97,96,,,83,84,86,85,88,89,,81,82,79,,,,,80,,,,98,99,100',
 '95,90,102,,106,,101,,87,91,93,92,94,,,,,,,,,,,,,,,,105,,,,97,96,,,83',
 '84,86,85,88,89,,81,82,,,,,,80,278,205,277,206,,275,208,279,273,272,',
 '274,276,,87,,,,,209,204,280,278,205,277,206,,275,208,279,273,272,,274',
 '276,,,207,281,,,209,204,280,278,205,277,206,,275,208,279,273,272,,274',
 '276,,,207,281,,,209,204,280,,,,,,,,,,,,,,,,207,281' ]
         racc_action_table = arr = ::Array.new(6060, nil)
         idx = 0
         clist.each do |str|
           str.split(',', -1).each do |i|
             arr[idx] = i.to_i unless i.empty?
             idx += 1
           end
         end
 
 clist = [
 '0,0,197,198,0,224,0,195,163,203,202,200,297,108,161,200,151,108,234',
 '224,114,297,163,0,163,151,163,234,161,0,161,0,161,0,0,128,0,0,0,129',
 '0,0,0,0,197,198,0,0,163,195,0,203,202,0,161,114,374,374,147,147,374',
 '0,374,374,129,199,123,0,107,199,163,0,0,45,0,0,0,48,137,374,0,48,107',
 '137,107,374,107,374,142,374,374,142,374,374,374,256,374,374,374,374',
 '306,45,374,374,306,45,374,306,107,374,5,5,131,139,5,160,5,374,139,338',
 '160,338,240,374,164,261,121,374,374,236,374,374,294,5,294,265,374,113',
 '164,5,164,5,164,5,5,267,5,5,5,5,5,5,5,5,121,235,5,5,121,232,5,149,149',
 '5,164,231,373,373,271,223,373,5,373,373,164,164,285,5,109,164,164,5',
 '5,287,5,5,164,289,290,373,5,104,109,293,109,373,109,373,221,373,373',
 '164,373,373,373,295,373,373,373,373,296,154,373,373,102,300,373,301',
 '109,373,302,303,371,371,304,217,371,373,371,371,308,73,71,373,61,60',
 '321,373,373,216,373,373,323,49,49,371,373,239,239,214,325,371,46,371',
 '212,371,371,332,371,371,371,333,371,371,371,371,40,192,371,371,39,341',
 '371,342,344,371,185,185,345,349,185,49,185,371,49,239,350,351,239,371',
 '38,357,358,371,371,361,371,371,191,185,6,1,371,378,49,185,382,185,239',
 '185,185,384,185,185,185,49,185,185,386,239,,,185,185,,,185,,,185,12',
 '12,,,12,,12,185,8,8,8,8,,185,,,,185,185,,185,185,,12,,,185,,,12,,12',
 ',12,12,,12,12,12,,12,12,,,,,12,12,,,12,,,12,13,13,,,13,,13,12,,,,,,12',
 ',,,12,12,,12,12,,13,,,12,,,13,,13,,13,13,,13,13,13,,13,13,,,,,13,13',
 ',,13,,,13,14,14,,,14,,14,13,,,,,,13,,,,13,13,,13,13,,14,,,13,,,14,,14',
 ',14,14,,14,14,14,,14,14,,,,,14,14,,,14,,,14,353,353,,,353,,353,14,,',
 ',,,14,,,,14,14,,14,14,,353,,,14,,,353,,353,,353,353,,353,353,353,,353',
 '353,353,353,,,353,353,,,353,,,353,340,340,,,340,,340,353,,,,,,353,,',
 ',353,353,,353,353,,340,,,353,,,340,,340,,340,340,,340,340,340,,340,340',
 ',,,,340,340,,,340,,,340,188,188,,,188,,188,340,,,,,,340,,,,340,340,',
 '340,340,,188,,,340,,,188,,188,,188,188,,188,188,188,,188,188,,,,,188',
 '188,,,188,,,188,41,41,,,41,,41,188,,,,,,188,,,,188,188,,188,188,,41',
 ',,188,,,41,,41,,41,41,,41,41,41,,41,41,,,,,41,41,,,41,,,41,42,42,,,42',
 ',42,41,,,,,,41,,,,41,41,,41,41,,42,,,41,,,42,,42,,42,42,,42,42,42,,42',
 '42,,,,,42,42,,,42,,,42,43,43,,,43,,43,42,,,,,,42,,,,42,42,,42,42,,43',
 ',,42,,,43,,43,,43,43,,43,43,43,,43,43,,,,,43,43,,,43,,,43,44,44,,,44',
 ',44,43,,,,,,43,,,,43,43,,43,43,,44,,,43,,,44,,44,,44,44,,44,44,44,,44',
 '44,,,,,44,44,,,44,,,44,189,189,,,189,,189,44,,,,,,44,,,,44,44,,44,44',
 ',189,,,44,,,189,,189,,189,189,,189,189,189,,189,189,,,,,189,189,,,189',
 ',,189,190,190,,,190,,190,189,,,,,,189,,,,189,189,,189,189,,190,,,189',
 ',,190,,190,,190,190,,190,190,190,,190,190,,,,,190,190,,,190,,,190,324',
 '324,,,324,,324,190,,,,,,190,165,,,190,190,,190,190,,324,,,190,,165,324',
 '165,324,165,324,324,,324,324,324,,324,324,,,,,324,324,,,324,,,324,165',
 ',219,219,,,219,324,219,219,165,165,,324,,165,165,324,324,,324,324,165',
 ',,219,324,237,237,,,219,,219,,219,219,165,219,219,219,,219,219,219,219',
 ',,219,219,,,219,,,219,51,51,,,51,51,51,219,,237,,,237,219,,,,219,219',
 ',219,219,,51,,,219,,,51,,51,237,51,51,,51,51,51,,51,51,,237,,,51,51',
 '201,201,51,,,51,52,52,,,52,52,52,51,,,,,,51,,,,51,51,,51,51,,52,,,51',
 ',,52,,52,201,52,52,201,52,52,52,,52,52,,,,,52,52,,,52,,,52,,201,53,53',
 ',,53,52,53,53,,,201,52,,,,52,52,,52,52,,,,53,52,,,,,53,,53,,53,53,,53',
 '53,53,,53,53,,,,,53,53,,,53,,,53,58,58,,,58,,58,53,,,,,,53,168,,,53',
 '53,,53,53,,58,,,53,,168,58,168,58,168,58,58,,58,58,58,,58,58,,,,,58',
 '58,,,58,,,58,168,,226,226,,,226,58,226,226,,,,58,,168,168,58,58,,58',
 '58,168,,,226,58,,,,,226,,226,,226,226,,226,226,226,,226,226,226,226',
 ',,226,226,,,226,,,226,150,150,,,150,,150,226,,,,,,226,,,,226,226,,226',
 '226,,150,,,226,,,150,,150,,150,150,,150,150,150,,150,150,150,150,,,150',
 '150,,,150,,,150,63,63,,,63,,63,150,,,,,,150,162,,,150,150,,150,150,',
 '63,,,150,,162,63,162,63,162,63,63,,63,63,63,,63,63,,,,,63,63,,,63,,',
 '63,162,,310,310,,,310,63,310,310,,,,63,,,,63,63,,63,63,162,,,310,63',
 ',,,,310,,310,,310,310,,310,310,310,,310,310,310,310,,,310,310,,,310',
 ',,310,72,72,,,72,,72,310,,,,,,310,,,,310,310,,310,310,,72,,,310,,,72',
 ',72,,72,72,,72,72,72,,72,72,72,72,,,72,72,,,72,,,72,309,309,,,309,,309',
 '72,,,,,,72,,,,72,72,,72,72,,309,,,72,,,309,,309,,309,309,,309,309,309',
 ',309,309,309,309,,,309,309,,,309,,,309,74,74,,,74,,74,309,,,,,,309,',
 ',,309,309,,309,309,,74,,,309,,,74,,74,,74,74,,74,74,74,,74,74,74,74',
 ',,74,74,,,74,,,74,75,75,,,75,,75,74,,,,,,74,,,,74,74,,74,74,,75,,,74',
 ',,75,,75,,75,75,,75,75,75,,75,75,75,75,,,75,75,,,75,,,75,76,76,,,76',
 ',76,75,,,,,,75,,,,75,75,,75,75,,76,,,75,,,76,,76,,76,76,,76,76,76,,76',
 '76,76,76,,,76,76,,,76,,,76,77,77,,,77,,77,76,,,,,,76,,,,76,76,,76,76',
 ',77,,,76,,,77,,77,,77,77,,77,77,77,,77,77,77,77,,,77,77,,,77,,,77,78',
 '78,,,78,,78,77,,,,,,77,,,,77,77,,77,77,,78,,,77,,,78,,78,,78,78,,78',
 '78,78,,78,78,78,78,,,78,78,,,78,,,78,79,79,,,79,,79,78,,,,,,78,,,,78',
 '78,,78,78,,79,,,78,,,79,,79,,79,79,,79,79,79,,79,79,,,,,79,79,,,79,',
 ',79,80,80,,,80,,80,79,,,,,,79,,,,79,79,,79,79,,80,,,79,,,80,,80,,80',
 '80,,80,80,80,,80,80,,,,,80,80,,,80,,,80,81,81,,,81,,81,80,,,,,,80,,',
 ',80,80,,80,80,,81,,,80,,,81,,81,,81,81,,81,81,81,,81,81,,,,,81,81,,',
 '81,,,81,82,82,,,82,,82,81,,,,,,81,,,,81,81,,81,81,,82,,,81,,,82,,82',
 ',82,82,,82,82,82,,82,82,,,,,82,82,,,82,,,82,83,83,,,83,,83,82,,,,,,82',
 ',,,82,82,,82,82,,83,,,82,,,83,,83,,83,83,,83,83,83,,83,83,,,,,83,83',
 ',,83,,,83,84,84,,,84,,84,83,,,,,,83,,,,83,83,,83,83,,84,,,83,,,84,,84',
 ',84,84,,84,84,84,,84,84,,,,,84,84,,,84,,,84,85,85,,,85,,85,84,,,,,,84',
 ',,,84,84,,84,84,,85,,,84,,,85,,85,,85,85,,85,85,85,,85,85,,,,,85,85',
 ',,85,,,85,86,86,,,86,,86,85,,,,,,85,,,,85,85,,85,85,,86,,,85,,,86,,86',
 ',86,86,,86,86,86,,86,86,,,,,86,86,,,86,,,86,87,87,,,87,,87,86,,,,,,86',
 ',,,86,86,,86,86,,87,,,86,,,87,,87,,87,87,,87,87,87,,87,87,,,,,87,87',
 ',,87,,,87,88,88,,,88,,88,87,,,,,,87,,,,87,87,,87,87,,88,,,87,,,88,,88',
 ',88,88,,88,88,88,,88,88,,,,,88,88,,,88,,,88,89,89,,,89,,89,88,,,,,,88',
 ',,,88,88,,88,88,,89,,,88,,,89,,89,,89,89,,89,89,89,,89,89,,,,,89,89',
 ',,89,,,89,90,90,,,90,,90,89,,,,,,89,,,,89,89,,89,89,,90,,,89,,,90,,90',
 ',90,90,,90,90,90,,90,90,,,,,90,90,,,90,,,90,91,91,,,91,,91,90,,,,,,90',
 ',,,90,90,,90,90,,91,,,90,,,91,,91,,91,91,,91,91,91,,91,91,,,,,91,91',
 ',,91,,,91,92,92,,,92,,92,91,,,,,,91,,,,91,91,,91,91,,92,,,91,,,92,,92',
 ',92,92,,92,92,92,,92,92,,,,,92,92,,,92,,,92,93,93,,,93,,93,92,,,,,,92',
 ',,,92,92,,92,92,,93,,,92,,,93,,93,,93,93,,93,93,93,,93,93,,,,,93,93',
 ',,93,,,93,94,94,,,94,,94,93,,,,,,93,,,,93,93,,93,93,,94,,,93,,,94,,94',
 ',94,94,,94,94,94,,94,94,,,,,94,94,,,94,,,94,95,95,,,95,,95,94,,,,,,94',
 ',,,94,94,,94,94,,95,,,94,,,95,,95,,95,95,,95,95,95,,95,95,,,,,95,95',
 ',,95,,,95,96,96,,,96,,96,95,,,,,,95,,,,95,95,,95,95,,96,,,95,,,96,,96',
 ',96,96,,96,96,96,,96,96,,,,,96,96,,,96,,,96,97,97,,,97,,97,96,,,,,,96',
 ',,,96,96,,96,96,,97,,,96,,,97,,97,,97,97,,97,97,97,,97,97,,,,,97,97',
 ',,97,,,97,98,98,,,98,,98,97,,,,,,97,,,,97,97,,97,97,,98,,,97,,,98,,98',
 ',98,98,,98,98,98,,98,98,,,,,98,98,,,98,,,98,99,99,,,99,,99,98,,,,,,98',
 ',,,98,98,,98,98,,99,,,98,,,99,,99,,99,99,,99,99,99,,99,99,,,,,99,99',
 ',,99,,,99,100,100,,,100,,100,99,,,,,,99,,,,99,99,,99,99,,100,,,99,,',
 '100,,100,,100,100,,100,100,100,,100,100,,,,,100,100,,,100,,,100,101',
 '101,,,101,,101,100,,,,,,100,,,,100,100,,100,100,,101,,,100,,,101,,101',
 ',101,101,,101,101,101,,101,101,,,,,101,101,,,101,,,101,,,298,298,,,298',
 '101,298,298,,,,101,,,101,101,101,,101,101,,,,298,101,,,,,298,,298,,298',
 '298,,298,298,298,,298,298,,,,,298,298,,,298,,,298,103,103,,,103,,103',
 '298,,,,,,298,,,,298,298,,298,298,,103,,,298,,,103,103,103,103,103,103',
 '103,103,103,103,,103,103,,,,,103,103,103,103,103,,,103,291,291,,,291',
 ',291,103,,,,,103,103,,,,103,103,,103,103,,291,,,103,,,291,,291,,291',
 '291,,291,291,291,,291,291,,,,,291,291,,,291,,,291,105,105,,,105,,105',
 '291,,,,,,291,,,,291,291,,291,291,,105,,,291,,,105,,105,,105,105,,105',
 '105,105,,105,105,,,,,105,105,,,105,,,105,106,106,,,106,,106,105,,,,',
 ',105,,,,105,105,,105,105,,106,,,105,,,106,,106,,106,106,,106,106,106',
 ',106,106,,,,,106,106,,,106,,,106,284,284,,,284,,284,106,,,,,,106,,,',
 '106,106,,106,106,,284,,,106,,,284,,284,,284,284,,284,284,284,,284,284',
 ',,,,284,284,,,284,,,284,270,270,,,270,,270,284,,,,,,284,,,,284,284,',
 '284,284,,270,,,284,,,270,,270,,270,270,,270,270,270,,270,270,,,,,270',
 '270,,,270,,,270,269,269,,,269,,269,270,,,,,,270,167,,,270,270,,270,270',
 ',269,,,270,,167,269,167,269,167,269,269,,269,269,269,,269,269,,,,,269',
 '269,,,269,,,269,167,,227,227,,,227,269,227,227,,,,269,,167,167,269,269',
 ',269,269,167,,,227,269,,,,,227,,227,,227,227,,227,227,227,,227,227,227',
 '227,,,227,227,,,227,,,227,111,111,,,111,,111,227,,,,,,227,,,,227,227',
 ',227,227,,111,111,,227,,,111,,111,,111,111,,111,111,111,,111,111,,,',
 ',111,111,,,111,,,111,266,266,,,266,,266,111,,,,,,111,,,,111,111,,111',
 '111,,266,,,111,,,266,,266,,266,266,,266,266,266,,266,266,,,,,266,266',
 ',,266,,,266,260,260,,,260,,260,266,,,,,,266,,,,266,266,,266,266,,260',
 ',,266,,,260,,260,,260,260,,260,260,260,,260,260,,,,,260,260,,,260,,',
 '260,115,115,,,115,,115,260,,,,,,260,,,,260,260,,260,260,,115,115,,260',
 ',,115,,115,,115,115,,115,115,115,,115,115,,,,,115,115,,,115,,,115,228',
 '228,,,228,,228,115,,,,,,115,,,,115,115,,115,115,,228,,,115,,,228,,228',
 ',228,228,,228,228,228,,228,228,,,,,228,228,,,228,,,228,243,243,,,243',
 '243,243,228,,,,,,228,,,,228,228,,228,228,,243,,,228,,,243,,243,,243',
 '243,,243,243,243,,243,243,,,,,243,243,,,243,,,243,230,230,,,230,,230',
 '243,,,,,,243,,,,243,243,,243,243,,230,,,243,,,230,,230,,230,230,,230',
 '230,230,,230,230,,,,,230,230,,,230,,,230,241,241,,,241,241,241,230,',
 ',,,,230,,,,230,230,,230,230,,241,,,230,,,241,,241,,241,241,,241,241',
 '241,,241,241,,,,,241,241,,,241,,,241,259,259,,,259,,259,241,,,,,,241',
 ',,,241,241,,241,241,,259,,,241,,,259,,259,,259,259,,259,259,259,,259',
 '259,,,,,259,259,,,259,,,259,122,122,,,122,,122,259,,,,,,259,,,,259,259',
 ',259,259,,122,,,259,,,122,,122,,122,122,,122,122,122,,122,122,,,,,122',
 '122,,,122,,,122,252,252,,,252,,252,122,,,,,,122,166,,,122,122,,122,122',
 ',252,,,122,,166,252,166,252,166,252,252,,252,252,252,,252,252,,,,,252',
 '252,,,252,,,252,166,,247,247,,,247,252,247,247,,,,252,,166,166,252,252',
 ',252,252,166,,,247,252,,,,,247,,247,,247,247,,247,247,247,,247,247,',
 ',,,247,247,,,247,,,247,245,245,,,245,,245,247,,,,,,247,,,,247,247,,247',
 '247,,245,,,247,,,245,,245,,245,245,,245,245,245,,245,245,,,,,245,245',
 ',,245,,,245,229,229,,,229,,229,245,,,,,,245,,,,245,245,,245,245,,229',
 ',,245,,,229,229,229,229,229,229,229,229,229,229,,229,229,,,,,229,229',
 '229,229,229,,,229,,,,,,,,229,,,,,229,229,,,,229,229,136,229,229,,,,',
 '229,,136,136,136,136,136,136,,136,,136,,,136,136,136,136,,,,,,,,,,,',
 ',,,,136,,,,136,136,,,136,136,136,136,136,136,,136,136,120,,120,,,136',
 ',,,120,120,120,120,120,120,,120,,120,,136,120,120,120,120,,,,,,,,,,',
 ',,,,,120,,,,120,120,,,120,120,120,120,120,120,,120,120,119,,119,,,120',
 ',,,119,119,119,119,119,119,,119,,119,,120,119,119,119,119,,,,,,,,,,',
 ',,,,,119,,,,119,119,,,119,119,119,119,119,119,,119,119,,141,,,,119,141',
 ',,,141,141,141,141,141,141,,141,,141,119,,141,141,141,141,,,,,,,,,,',
 ',,,,,141,,,,141,141,,,141,141,141,141,141,141,,141,141,118,,118,,,141',
 ',,,118,118,118,118,118,118,,118,,118,,141,118,118,118,118,,,,,,,,,,',
 ',,,,,118,,,,118,118,,,118,118,118,118,118,118,,118,118,145,,,,,118,',
 ',,145,145,145,145,145,145,,145,,145,,118,145,145,145,145,,,,,,,,,,,',
 ',,,,145,,,,145,145,,,145,145,145,145,145,145,,145,145,116,,116,,,145',
 ',,,116,116,116,116,116,116,,116,,116,,145,116,116,116,116,,,,,,,,,,',
 ',,,,,116,,,,116,116,,,116,116,116,116,116,116,,116,116,,110,,,,116,',
 ',,,110,110,110,110,110,110,,110,,110,116,110,110,110,110,110,,,,,,,',
 ',,,,,,,,110,,,,110,110,,,110,110,110,110,110,110,,110,110,314,,,,,110',
 ',,,314,314,314,314,314,314,,314,,314,,110,314,314,314,314,,,,,,,,,,',
 ',,,,,314,,,,314,314,,,314,314,314,314,314,314,,314,314,317,,,,,314,',
 ',,317,317,317,317,317,317,,317,,317,,314,317,317,317,317,,,,,,,,,,,',
 ',,,,317,,,,317,317,,,317,317,317,317,317,317,,317,317,152,,,,,317,,',
 ',152,152,152,152,152,152,,152,,152,,317,152,152,152,152,,,,,,,,,,,,',
 ',,,152,,,,152,152,,,152,152,152,152,152,152,,152,152,322,,,,,152,,,',
 '322,322,322,322,322,322,,322,,322,,152,322,322,322,322,,,,,,,,,,,,,',
 ',,322,,,,322,322,,,322,322,322,322,322,322,,322,322,211,,,,,322,,,,211',
 '211,211,211,211,211,,211,,211,,322,211,211,211,211,,,,,,,,,,,,,,,,211',
 ',,,211,211,,,211,211,211,211,211,211,,211,211,330,,,,,211,,,,330,330',
 '330,330,330,330,,330,,330,,211,330,330,330,330,,,,,,,,,,,,,,,,330,,',
 ',330,330,,,330,330,330,330,330,330,,330,330,331,,,,,330,,,,331,331,331',
 '331,331,331,,331,,331,,330,331,331,331,331,,,,,,,,,,,,,,,,331,,,,331',
 '331,,,331,331,331,331,331,331,,331,331,337,,,,,331,,,,337,337,337,337',
 '337,337,,337,,337,,331,337,337,337,337,,,,,,,,,,,,,,,,337,,,,337,337',
 ',,337,337,337,337,337,337,,337,337,187,,,,,337,,,,187,187,187,187,187',
 '187,187,187,,187,,337,187,187,187,187,,,,,,,,,,,,,,,,187,,,,187,187',
 ',,187,187,187,187,187,187,,187,187,11,,11,,,187,,,,11,11,11,11,11,11',
 ',11,,11,,187,11,11,11,11,,,,,,,,,,,,,,,,11,,,,11,11,,,11,11,11,11,11',
 '11,,11,11,,182,,,,11,182,,,,182,182,182,182,182,182,,182,169,182,11',
 ',182,182,182,182,,,,,,,169,,169,,169,,,,,182,,,,182,182,,,182,182,182',
 '182,182,182,,182,182,169,,,170,,182,,,169,169,169,169,,,,169,169,170',
 ',170,182,170,169,,,,171,,,,,,,,,,,169,,,171,,171,170,171,,172,,,,,170',
 '170,170,170,,,,170,170,172,,172,,172,170,171,,,,,,,,171,171,171,171',
 '171,171,170,171,171,,,,172,,171,,,173,,,172,172,172,172,172,172,,172',
 '172,171,173,173,,173,172,173,,174,173,,,,,,,,,,,172,174,174,,174,,174',
 ',173,174,,,,,,,173,173,173,173,173,173,,173,173,,,,174,,173,,,175,,',
 '174,174,174,174,174,174,,174,174,173,175,175,,175,174,175,,176,175,',
 ',,,,,,,,,174,176,176,,176,,176,,175,176,,,,,,,175,175,175,175,175,175',
 ',175,175,,,,176,,175,,,,,177,176,176,176,176,176,176,,176,176,175,,177',
 '177,177,176,177,,177,,178,177,177,177,177,,,,,,176,,178,178,178,,178',
 ',178,,177,178,178,178,178,,,,177,177,177,177,177,177,,177,177,,,,178',
 ',177,,,178,,,178,178,178,178,178,178,,178,178,177,181,,,,178,,,,,181',
 '181,181,181,181,181,,181,,181,178,,181,181,181,181,,,,,,,,,,,,,,,,181',
 ',,,181,181,,,181,181,181,181,181,181,,181,181,180,,,,,181,,,,180,180',
 '180,180,180,180,,180,,180,,181,180,180,180,180,,,,,,,,,,,,,,,,180,,',
 ',180,180,,,180,180,180,180,180,180,,180,180,179,,,,,180,,,,179,179,179',
 '179,179,179,,179,,179,,180,179,179,179,179,,,,,,,,,,,,,,,,179,,,,179',
 '179,,,179,179,179,179,179,179,,179,179,,,,,,179,210,210,210,210,,210',
 '210,210,210,210,,210,210,,179,,,,,210,210,210,268,268,268,268,,268,268',
 '268,268,268,,268,268,,,210,210,,,268,268,268,263,263,263,263,,263,263',
 '263,263,263,,263,263,,,268,268,,,263,263,263,,,,,,,,,,,,,,,,263,263' ]
         racc_action_check = arr = ::Array.new(6060, nil)
         idx = 0
         clist.each do |str|
           str.split(',', -1).each do |i|
             arr[idx] = i.to_i unless i.empty?
             idx += 1
           end
         end
 
 racc_action_pointer = [
     -2,   301,   nil,   nil,   nil,   108,   288,   nil,   274,   nil,
    nil,  5378,   328,   382,   436,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   265,   200,
    241,   652,   706,   760,   814,    65,   208,   nil,    41,   241,
    nil,  1086,  1140,  1196,   nil,   nil,   nil,   nil,  1250,   nil,
    160,   209,   nil,  1414,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   232,  1524,   219,  1632,  1686,  1740,  1794,  1848,  1902,
   1956,  2010,  2064,  2118,  2172,  2226,  2280,  2334,  2388,  2442,
   2496,  2550,  2604,  2658,  2712,  2766,  2820,  2874,  2928,  2982,
   3036,  3090,   174,  3200,   183,  3308,  3362,    62,   -23,   172,
   4808,  3634,   nil,   129,   -15,  3796,  4750,   nil,  4636,  4521,
   4464,   118,  4120,    41,   nil,   nil,   nil,   nil,    10,    27,
    nil,    92,   nil,   nil,   nil,   nil,  4407,    71,   nil,   106,
    nil,  4579,    79,   nil,   nil,  4693,   nil,    54,   nil,   159,
   1360,   -10,  4979,   nil,   199,   nil,   nil,   nil,   nil,   nil,
    108,     8,  1424,     2,   118,   986,  4184,  3534,  1260,  5453,
   5496,  5519,  5539,  5584,  5604,  5649,  5669,  5716,  5736,  5908,
   5851,  5794,  5436,   nil,   nil,   274,   nil,  5321,   598,   868,
    922,   257,   255,   nil,   nil,    -4,   nil,    -9,    -8,    29,
    -25,  1134,    -1,    -2,   nil,   nil,   nil,   nil,   nil,   nil,
   5946,  5093,   207,   nil,   226,   nil,   227,   155,   nil,  1032,
    nil,   186,   nil,   154,    -7,   nil,  1306,  3580,  3850,  4338,
   3958,   124,   122,   nil,    -8,   147,   121,  1057,   nil,   245,
     82,  4012,   nil,  3904,   nil,  4284,   nil,  4230,   nil,   nil,
    nil,   nil,  4174,   nil,   nil,   nil,    83,   nil,   nil,  4066,
   3742,   113,   nil,  5990,   nil,   126,  3688,   136,  5968,  3524,
   3470,   156,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,  3416,   150,   nil,   174,   nil,   117,
    153,  3254,   nil,   184,   100,   196,   178,     0,  3146,   nil,
    174,   205,   179,   212,   216,   nil,    64,   nil,   218,  1578,
   1470,   nil,   nil,   nil,  4865,   nil,   nil,  4922,   nil,   nil,
    nil,   210,  5036,   233,   976,   238,   nil,   nil,   nil,   nil,
   5150,  5207,   248,   191,   nil,   nil,   nil,  5264,    87,   nil,
    544,   263,   241,   nil,   266,   270,   nil,   nil,   nil,   270,
    277,   278,   nil,   490,   nil,   nil,   nil,   265,   283,   nil,
    nil,   286,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   220,   nil,   164,    54,   nil,   nil,   nil,   294,   nil,
    nil,   nil,   297,   nil,   302,   nil,   309,   nil,   nil,   nil,
    nil,   nil ]
 
 racc_action_default = [
   -224,  -225,    -1,    -2,    -3,    -4,    -5,    -8,   -10,   -11,
    -16,  -107,  -225,  -225,  -225,   -45,   -46,   -47,   -48,   -49,
    -50,   -51,   -52,   -53,   -54,   -55,   -56,   -57,   -58,   -59,
    -60,   -61,   -62,   -63,   -64,   -65,   -66,   -67,   -72,   -73,
    -77,  -225,  -225,  -225,  -225,  -225,  -118,  -120,  -225,  -225,
   -165,  -225,  -225,  -225,  -178,  -179,  -180,  -181,  -225,  -183,
   -225,  -194,  -197,  -225,  -199,  -200,  -201,  -202,  -203,  -204,
   -205,  -225,  -225,    -7,  -225,  -225,  -225,  -225,  -225,  -225,
   -225,  -225,  -225,  -225,  -225,  -225,  -225,  -225,  -225,  -225,
   -225,  -225,  -225,  -225,  -225,  -225,  -225,  -225,  -225,  -225,
   -225,  -225,  -225,  -127,  -122,  -224,  -224,   -28,  -225,   -35,
   -225,  -225,   -74,  -225,  -225,  -225,  -225,   -84,  -225,  -225,
   -225,  -225,  -225,  -224,  -137,  -156,  -157,  -119,  -224,  -224,
   -146,  -148,  -149,  -150,  -151,  -152,   -43,  -225,  -168,  -225,
   -171,  -225,  -225,  -174,  -175,  -187,  -182,  -225,  -190,  -225,
   -225,  -225,  -198,   392,    -6,    -9,   -12,   -13,   -14,   -15,
   -225,   -18,   -19,   -20,   -21,   -22,   -23,   -24,   -25,   -26,
    -27,   -29,   -30,   -31,   -32,   -33,   -34,   -36,   -37,   -38,
    -39,   -40,  -225,   -41,  -102,  -225,   -78,  -225,  -217,  -223,
   -211,  -208,  -206,  -116,  -128,  -200,  -131,  -204,  -225,  -214,
   -212,  -220,  -202,  -203,  -210,  -215,  -216,  -218,  -219,  -221,
   -127,  -126,  -225,  -125,  -225,   -42,  -206,   -69,   -79,  -225,
    -82,  -206,  -161,  -164,  -225,   -76,  -225,  -225,  -225,  -127,
   -225,  -208,  -224,  -158,  -225,  -225,  -225,  -225,  -154,  -225,
   -225,  -225,  -166,  -225,  -169,  -225,  -172,  -225,  -184,  -185,
   -186,  -188,  -225,  -191,  -192,  -193,  -206,  -195,   -17,  -225,
   -225,  -206,  -104,  -127,  -115,  -225,  -209,  -225,  -207,  -225,
   -225,  -206,  -130,  -132,  -211,  -212,  -213,  -214,  -217,  -220,
   -222,  -223,  -123,  -124,  -207,  -225,   -71,  -225,   -81,  -225,
   -207,  -225,   -75,  -225,   -87,  -225,   -93,  -225,  -225,   -97,
   -208,  -206,  -208,  -225,  -225,  -140,  -225,  -159,  -206,  -224,
   -225,  -147,  -155,  -153,   -44,  -167,  -170,  -177,  -173,  -176,
   -189,  -225,  -106,  -225,  -207,  -206,  -110,  -117,  -111,  -129,
   -133,  -134,  -225,   -68,   -80,   -83,  -162,  -163,   -87,   -86,
   -225,  -225,   -93,   -92,  -225,  -225,  -101,   -96,   -98,  -225,
   -225,  -225,  -113,  -224,  -141,  -142,  -143,  -225,  -225,  -138,
   -139,  -225,  -145,  -196,  -103,  -105,  -114,  -121,   -70,   -85,
    -88,  -225,   -91,  -225,  -225,  -108,  -109,  -112,  -225,  -160,
   -135,  -144,  -225,   -90,  -225,   -95,  -225,  -100,  -136,   -89,
    -94,   -99 ]
 
 racc_goto_table = [
      2,   112,     4,   144,   107,   109,   110,   128,   146,   192,
    134,   132,   191,   265,   221,   184,   343,   232,     1,   339,
    358,   311,   235,   312,   299,   156,   157,   158,   159,   212,
    214,   231,   267,   116,   118,   119,   120,    73,   261,   327,
    263,   345,   329,   136,   136,   141,   298,   370,   218,   304,
    145,   256,   354,   303,   236,   152,   285,   183,   336,   142,
    155,   289,   372,   369,   378,   253,   254,     3,   251,   252,
    250,   136,   161,   162,   163,   164,   165,   166,   167,   168,
    169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
    179,   180,   181,   182,   348,   187,   321,   211,   211,   262,
    148,   323,   150,   136,   154,   nil,   nil,   136,   137,   139,
    nil,   332,   nil,   nil,   187,   nil,   271,   nil,   nil,   nil,
    nil,   nil,   349,   nil,   351,   233,   nil,   nil,   nil,   nil,
    233,   238,   nil,   nil,   308,   301,   160,   nil,   300,   302,
    nil,   350,   nil,   nil,   nil,   nil,   nil,   nil,   357,   nil,
    255,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   128,   nil,
    nil,   nil,   134,   132,   nil,   366,   nil,   nil,   216,   325,
    nil,   nil,   224,   nil,   nil,   nil,   nil,   182,   nil,   286,
    116,   118,   119,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   319,   134,   132,
    134,   132,   320,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   287,
    136,   187,   187,   nil,   nil,   nil,   293,   295,   nil,   nil,
    nil,   nil,   nil,   314,   305,   314,   nil,   317,   365,   141,
    nil,   nil,   nil,   nil,   145,   nil,   nil,   nil,   nil,   nil,
    nil,   314,   322,   nil,   nil,   nil,   nil,   nil,   187,   nil,
    nil,   330,   331,   nil,   nil,   355,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   314,   nil,   nil,   nil,
    nil,   nil,   nil,   337,   nil,   nil,   nil,   nil,   nil,   nil,
    136,   nil,   nil,   nil,   nil,   368,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    361,   360,   nil,   nil,   nil,   nil,   182,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   116,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   360,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   382,   nil,   384,   386 ]
 
 racc_goto_check = [
      2,    39,     4,    76,    10,    10,    10,    64,    81,    56,
     31,    37,    54,    55,    44,    51,    47,    65,     1,    46,
     66,    72,    65,    72,    49,     8,     8,     8,     8,    60,
     60,    54,    38,    10,    10,    10,    10,     6,    52,    57,
     58,    50,    61,    10,    10,    10,    48,    45,    43,    68,
     10,    44,    69,    55,    71,    10,    38,    13,    74,    75,
      7,    38,    47,    46,    66,    77,    78,     3,    82,    83,
     85,    10,    10,    10,    10,    10,    10,    10,    10,    10,
     10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
     10,    10,    10,    10,    49,    10,    38,    10,    10,    51,
     86,    38,    87,    10,     6,   nil,   nil,    10,    12,    12,
    nil,    38,   nil,   nil,    10,   nil,    56,   nil,   nil,   nil,
    nil,   nil,    55,   nil,    55,     4,   nil,   nil,   nil,   nil,
      4,     4,   nil,   nil,    44,    56,    12,   nil,    54,    54,
    nil,    38,   nil,   nil,   nil,   nil,   nil,   nil,    38,   nil,
      2,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    64,   nil,
    nil,   nil,    31,    37,   nil,    38,   nil,   nil,    12,    56,
    nil,   nil,    12,   nil,   nil,   nil,   nil,    10,   nil,    39,
     10,    10,    10,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,    76,    31,    37,
     31,    37,    81,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     2,
     10,    10,    10,   nil,   nil,   nil,     2,     2,   nil,   nil,
    nil,   nil,   nil,    10,     4,    10,   nil,    10,    51,    10,
    nil,   nil,   nil,   nil,    10,   nil,   nil,   nil,   nil,   nil,
    nil,    10,    10,   nil,   nil,   nil,   nil,   nil,    10,   nil,
    nil,    10,    10,   nil,   nil,    64,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,    10,   nil,   nil,   nil,
    nil,   nil,   nil,    10,   nil,   nil,   nil,   nil,   nil,   nil,
     10,   nil,   nil,   nil,   nil,    39,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
      2,     4,   nil,   nil,   nil,   nil,    10,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,    10,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,     4,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,     2,   nil,     2,     2 ]
 
 racc_goto_pointer = [
    nil,    18,     0,    67,     2,   nil,    32,   -14,   -50,   nil,
     -8,   nil,    57,   -44,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   -39,   nil,   nil,   nil,   nil,   nil,   -38,  -160,   -38,
    nil,   nil,   nil,   -65,  -100,  -293,  -275,  -280,  -182,  -204,
   -256,   -86,  -147,   nil,   -91,  -178,   -94,  -227,  -147,   nil,
    -76,  -226,   nil,   nil,   -41,  -106,  -289,   nil,  -183,  -254,
    nil,   -75,  -216,   nil,  -232,     6,   -50,   -84,   -83,   nil,
    nil,   -50,   -79,   -78,   nil,   -77,    40,    41 ]
 
 racc_goto_default = [
    nil,   nil,   359,   nil,   213,     5,     6,     7,     8,     9,
     11,    10,   297,   nil,    15,    38,    16,    17,    18,    19,
     20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
     30,    31,    32,    33,    34,    35,    36,    37,   nil,   nil,
     39,    40,   113,   nil,   nil,   117,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,    44,   nil,   nil,   nil,   193,   nil,   104,
    nil,   194,   198,   196,   124,   nil,   nil,   123,   nil,   nil,
    129,   nil,   130,   131,   222,   nil,   nil,    54,    55,    56,
     58,   nil,   nil,   nil,   147,   nil,   nil,   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
   1, 87, :_reduce_1,
   1, 87, :_reduce_2,
   1, 87, :_reduce_none,
   1, 88, :_reduce_4,
   1, 91, :_reduce_5,
   3, 91, :_reduce_6,
   2, 91, :_reduce_7,
   1, 92, :_reduce_8,
   3, 92, :_reduce_9,
   1, 93, :_reduce_none,
   1, 94, :_reduce_11,
   3, 94, :_reduce_12,
   3, 94, :_reduce_13,
   3, 94, :_reduce_14,
   3, 94, :_reduce_15,
   1, 96, :_reduce_none,
   4, 96, :_reduce_17,
   3, 96, :_reduce_18,
   3, 96, :_reduce_19,
   3, 96, :_reduce_20,
   3, 96, :_reduce_21,
   3, 96, :_reduce_22,
   3, 96, :_reduce_23,
   3, 96, :_reduce_24,
   3, 96, :_reduce_25,
   3, 96, :_reduce_26,
   3, 96, :_reduce_27,
   2, 96, :_reduce_28,
   3, 96, :_reduce_29,
   3, 96, :_reduce_30,
   3, 96, :_reduce_31,
   3, 96, :_reduce_32,
   3, 96, :_reduce_33,
   3, 96, :_reduce_34,
   2, 96, :_reduce_35,
   3, 96, :_reduce_36,
   3, 96, :_reduce_37,
   3, 96, :_reduce_38,
   3, 96, :_reduce_39,
   3, 96, :_reduce_40,
   3, 96, :_reduce_41,
   3, 96, :_reduce_42,
   1, 98, :_reduce_43,
   3, 98, :_reduce_44,
   1, 97, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 101, :_reduce_none,
   1, 102, :_reduce_none,
   1, 102, :_reduce_none,
   1, 102, :_reduce_none,
   1, 102, :_reduce_none,
   1, 102, :_reduce_none,
   1, 102, :_reduce_none,
   1, 102, :_reduce_none,
   1, 102, :_reduce_none,
   1, 102, :_reduce_none,
   1, 118, :_reduce_66,
   1, 118, :_reduce_67,
   5, 100, :_reduce_68,
   3, 100, :_reduce_69,
   6, 100, :_reduce_70,
   4, 100, :_reduce_71,
   1, 100, :_reduce_72,
   1, 104, :_reduce_73,
   2, 104, :_reduce_74,
   4, 126, :_reduce_75,
   3, 126, :_reduce_76,
   1, 126, :_reduce_77,
   3, 127, :_reduce_78,
   2, 125, :_reduce_79,
   3, 129, :_reduce_80,
   2, 129, :_reduce_81,
   2, 128, :_reduce_82,
   4, 128, :_reduce_83,
   2, 107, :_reduce_84,
   5, 131, :_reduce_85,
   4, 131, :_reduce_86,
   0, 132, :_reduce_none,
   2, 132, :_reduce_88,
   4, 132, :_reduce_89,
   3, 132, :_reduce_90,
   6, 108, :_reduce_91,
   5, 108, :_reduce_92,
   0, 133, :_reduce_none,
   4, 133, :_reduce_94,
   3, 133, :_reduce_95,
   5, 106, :_reduce_96,
   1, 134, :_reduce_97,
   2, 134, :_reduce_98,
   5, 135, :_reduce_99,
   4, 135, :_reduce_100,
   1, 136, :_reduce_101,
   1, 99, :_reduce_none,
   4, 99, :_reduce_103,
   1, 138, :_reduce_104,
   3, 138, :_reduce_105,
   3, 137, :_reduce_106,
   1, 95, :_reduce_107,
   6, 95, :_reduce_108,
   6, 95, :_reduce_109,
   5, 95, :_reduce_110,
   5, 95, :_reduce_111,
   6, 95, :_reduce_112,
   5, 95, :_reduce_113,
   4, 143, :_reduce_114,
   1, 144, :_reduce_115,
   1, 140, :_reduce_116,
   3, 140, :_reduce_117,
   1, 139, :_reduce_118,
   2, 139, :_reduce_119,
   1, 139, :_reduce_120,
   6, 105, :_reduce_121,
   2, 105, :_reduce_122,
   3, 145, :_reduce_123,
   3, 145, :_reduce_124,
   1, 146, :_reduce_none,
   1, 146, :_reduce_none,
   0, 142, :_reduce_127,
   1, 142, :_reduce_128,
   3, 142, :_reduce_129,
   1, 148, :_reduce_none,
   1, 148, :_reduce_none,
   1, 148, :_reduce_none,
   3, 147, :_reduce_133,
   3, 147, :_reduce_134,
   6, 109, :_reduce_135,
   7, 110, :_reduce_136,
   1, 153, :_reduce_137,
   1, 152, :_reduce_none,
   1, 152, :_reduce_none,
   1, 154, :_reduce_none,
   2, 154, :_reduce_141,
   1, 155, :_reduce_none,
   1, 155, :_reduce_none,
   6, 111, :_reduce_144,
   5, 111, :_reduce_145,
   1, 156, :_reduce_146,
   3, 156, :_reduce_147,
   1, 158, :_reduce_148,
   1, 158, :_reduce_149,
   1, 158, :_reduce_150,
   1, 158, :_reduce_none,
   1, 159, :_reduce_152,
   3, 159, :_reduce_153,
   1, 157, :_reduce_none,
   2, 157, :_reduce_155,
   1, 150, :_reduce_156,
   1, 150, :_reduce_157,
   1, 151, :_reduce_158,
   2, 151, :_reduce_159,
   4, 151, :_reduce_160,
   1, 130, :_reduce_161,
   3, 130, :_reduce_162,
   3, 160, :_reduce_163,
   1, 160, :_reduce_164,
   1, 103, :_reduce_165,
   3, 113, :_reduce_166,
   4, 113, :_reduce_167,
   2, 113, :_reduce_168,
   3, 113, :_reduce_169,
   4, 113, :_reduce_170,
   2, 113, :_reduce_171,
   3, 116, :_reduce_172,
   4, 116, :_reduce_173,
   2, 116, :_reduce_174,
   1, 161, :_reduce_175,
   3, 161, :_reduce_176,
   3, 162, :_reduce_177,
   1, 123, :_reduce_none,
   1, 123, :_reduce_none,
   1, 123, :_reduce_none,
   1, 163, :_reduce_181,
   2, 164, :_reduce_182,
   1, 166, :_reduce_183,
   1, 168, :_reduce_184,
   1, 169, :_reduce_185,
   2, 167, :_reduce_186,
   1, 170, :_reduce_187,
   1, 171, :_reduce_188,
   2, 171, :_reduce_189,
   2, 165, :_reduce_190,
   2, 172, :_reduce_191,
   2, 172, :_reduce_192,
   3, 89, :_reduce_193,
   0, 173, :_reduce_194,
   2, 173, :_reduce_195,
   4, 173, :_reduce_196,
   1, 112, :_reduce_197,
   2, 112, :_reduce_198,
   1, 119, :_reduce_199,
   1, 122, :_reduce_200,
   1, 120, :_reduce_201,
   1, 121, :_reduce_202,
   1, 115, :_reduce_203,
   1, 114, :_reduce_204,
   1, 117, :_reduce_205,
   0, 124, :_reduce_none,
   1, 124, :_reduce_207,
   0, 141, :_reduce_none,
   1, 141, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   1, 149, :_reduce_none,
   0, 90, :_reduce_224 ]
 
 racc_reduce_n = 225
 
 racc_shift_n = 392
 
 racc_token_table = {
   false => 0,
   :error => 1,
   :STRING => 2,
   :DQPRE => 3,
   :DQMID => 4,
   :DQPOST => 5,
   :LBRACK => 6,
   :RBRACK => 7,
   :LBRACE => 8,
   :RBRACE => 9,
   :SYMBOL => 10,
   :FARROW => 11,
   :COMMA => 12,
   :TRUE => 13,
   :FALSE => 14,
   :EQUALS => 15,
   :APPENDS => 16,
   :DELETES => 17,
   :LESSEQUAL => 18,
   :NOTEQUAL => 19,
   :DOT => 20,
   :COLON => 21,
   :LLCOLLECT => 22,
   :RRCOLLECT => 23,
   :QMARK => 24,
   :LPAREN => 25,
   :RPAREN => 26,
   :ISEQUAL => 27,
   :GREATEREQUAL => 28,
   :GREATERTHAN => 29,
   :LESSTHAN => 30,
   :IF => 31,
   :ELSE => 32,
   :DEFINE => 33,
   :ELSIF => 34,
   :VARIABLE => 35,
   :CLASS => 36,
   :INHERITS => 37,
   :NODE => 38,
   :BOOLEAN => 39,
   :NAME => 40,
   :SEMIC => 41,
   :CASE => 42,
   :DEFAULT => 43,
   :AT => 44,
   :ATAT => 45,
   :LCOLLECT => 46,
   :RCOLLECT => 47,
   :CLASSREF => 48,
   :NOT => 49,
   :OR => 50,
   :AND => 51,
   :UNDEF => 52,
   :PARROW => 53,
   :PLUS => 54,
   :MINUS => 55,
   :TIMES => 56,
   :DIV => 57,
   :LSHIFT => 58,
   :RSHIFT => 59,
   :UMINUS => 60,
   :MATCH => 61,
   :NOMATCH => 62,
   :REGEX => 63,
   :IN_EDGE => 64,
   :OUT_EDGE => 65,
   :IN_EDGE_SUB => 66,
   :OUT_EDGE_SUB => 67,
   :IN => 68,
   :UNLESS => 69,
   :PIPE => 70,
   :LAMBDA => 71,
   :SELBRACE => 72,
   :NUMBER => 73,
   :HEREDOC => 74,
   :SUBLOCATE => 75,
   :RENDER_STRING => 76,
   :RENDER_EXPR => 77,
   :EPP_START => 78,
   :LOW => 79,
   :HIGH => 80,
   :CALL => 81,
   :LISTSTART => 82,
   :MODULO => 83,
   :TITLE_COLON => 84,
   :CASE_COLON => 85 }
 
 racc_nt_base = 86
 
 racc_use_result_var = true
 
 Racc_arg = [
   racc_action_table,
   racc_action_check,
   racc_action_default,
   racc_action_pointer,
   racc_goto_table,
   racc_goto_check,
   racc_goto_default,
   racc_goto_pointer,
   racc_nt_base,
   racc_reduce_table,
   racc_token_table,
   racc_shift_n,
   racc_reduce_n,
   racc_use_result_var ]
 
 Racc_token_to_s_table = [
   "$end",
   "error",
   "STRING",
   "DQPRE",
   "DQMID",
   "DQPOST",
   "LBRACK",
   "RBRACK",
   "LBRACE",
   "RBRACE",
   "SYMBOL",
   "FARROW",
   "COMMA",
   "TRUE",
   "FALSE",
   "EQUALS",
   "APPENDS",
   "DELETES",
   "LESSEQUAL",
   "NOTEQUAL",
   "DOT",
   "COLON",
   "LLCOLLECT",
   "RRCOLLECT",
   "QMARK",
   "LPAREN",
   "RPAREN",
   "ISEQUAL",
   "GREATEREQUAL",
   "GREATERTHAN",
   "LESSTHAN",
   "IF",
   "ELSE",
   "DEFINE",
   "ELSIF",
   "VARIABLE",
   "CLASS",
   "INHERITS",
   "NODE",
   "BOOLEAN",
   "NAME",
   "SEMIC",
   "CASE",
   "DEFAULT",
   "AT",
   "ATAT",
   "LCOLLECT",
   "RCOLLECT",
   "CLASSREF",
   "NOT",
   "OR",
   "AND",
   "UNDEF",
   "PARROW",
   "PLUS",
   "MINUS",
   "TIMES",
   "DIV",
   "LSHIFT",
   "RSHIFT",
   "UMINUS",
   "MATCH",
   "NOMATCH",
   "REGEX",
   "IN_EDGE",
   "OUT_EDGE",
   "IN_EDGE_SUB",
   "OUT_EDGE_SUB",
   "IN",
   "UNLESS",
   "PIPE",
   "LAMBDA",
   "SELBRACE",
   "NUMBER",
   "HEREDOC",
   "SUBLOCATE",
   "RENDER_STRING",
   "RENDER_EXPR",
   "EPP_START",
   "LOW",
   "HIGH",
   "CALL",
   "LISTSTART",
   "MODULO",
   "TITLE_COLON",
   "CASE_COLON",
   "$start",
   "program",
   "statements",
   "epp_expression",
   "nil",
   "syntactic_statements",
   "syntactic_statement",
   "any_expression",
   "relationship_expression",
   "resource_expression",
   "expression",
   "higher_precedence",
   "expressions",
   "selector_entries",
   "call_function_expression",
   "primary_expression",
   "literal_expression",
   "variable",
   "call_method_with_lambda_expression",
   "collection_expression",
   "case_expression",
   "if_expression",
   "unless_expression",
   "definition_expression",
   "hostclass_expression",
   "node_definition_expression",
   "epp_render_expression",
   "array",
   "boolean",
   "default",
   "hash",
   "regex",
   "text_or_name",
   "number",
   "type",
   "undef",
   "name",
   "quotedtext",
   "endcomma",
   "lambda",
   "call_method_expression",
   "named_access",
   "lambda_parameter_list",
   "lambda_rest",
   "parameters",
   "if_part",
   "else",
   "unless_else",
   "case_options",
   "case_option",
   "case_colon",
   "selector_entry",
   "selector_entry_list",
   "at",
   "resourceinstances",
   "endsemi",
   "attribute_operations",
   "resourceinst",
   "title_colon",
   "collect_query",
   "optional_query",
   "attribute_operation",
   "attribute_name",
   "keyword",
   "classname",
   "parameter_list",
   "opt_statements",
   "stacked_classname",
   "classparent",
   "classnameordefault",
   "hostnames",
   "nodeparent",
   "hostname",
   "dotted_name",
   "parameter",
   "hashpairs",
   "hashpair",
   "string",
   "dq_string",
   "heredoc",
   "dqpre",
   "dqrval",
   "dqpost",
   "dqmid",
   "text_expression",
   "dqtail",
   "sublocated_text",
   "epp_parameters_list" ]
 
 Racc_debug_parser = false
 
 ##### State transition tables end #####
 
 # reduce 0 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 64)
   def _reduce_1(val, _values, result)
      result = create_program(Factory.block_or_expression(*val[0])) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 65)
   def _reduce_2(val, _values, result)
-     result = Factory.block_or_expression(*val[0]) 
+     result = create_program(Factory.block_or_expression(*val[0])) 
     result
   end
 .,.,
 
 # reduce 3 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 70)
   def _reduce_4(val, _values, result)
      result = transform_calls(val[0]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 76)
   def _reduce_5(val, _values, result)
      result = [val[0]]
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 77)
   def _reduce_6(val, _values, result)
      result = val[0].push val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 78)
   def _reduce_7(val, _values, result)
      result = val[0].push val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 82)
   def _reduce_8(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 83)
   def _reduce_9(val, _values, result)
      result = aryfy(val[0]).push val[2] 
     result
   end
 .,.,
 
 # reduce 10 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 89)
   def _reduce_11(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 90)
   def _reduce_12(val, _values, result)
      result = val[0].relop(val[1][:value], val[2]); loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 91)
   def _reduce_13(val, _values, result)
      result = val[0].relop(val[1][:value], val[2]); loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 92)
   def _reduce_14(val, _values, result)
      result = val[0].relop(val[1][:value], val[2]); loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 93)
   def _reduce_15(val, _values, result)
      result = val[0].relop(val[1][:value], val[2]); loc result, val[1] 
     result
   end
 .,.,
 
 # reduce 16 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 100)
   def _reduce_17(val, _values, result)
      result = val[0][*val[2]]         ; loc result, val[0], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 101)
   def _reduce_18(val, _values, result)
      result = val[0].in val[2]        ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 102)
   def _reduce_19(val, _values, result)
      result = val[0] =~  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 103)
   def _reduce_20(val, _values, result)
      result = val[0].mne val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 104)
   def _reduce_21(val, _values, result)
      result = val[0] +   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 105)
   def _reduce_22(val, _values, result)
      result = val[0] -   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 106)
   def _reduce_23(val, _values, result)
      result = val[0] /   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 107)
   def _reduce_24(val, _values, result)
      result = val[0] *   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 108)
   def _reduce_25(val, _values, result)
      result = val[0] %   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 109)
   def _reduce_26(val, _values, result)
      result = val[0] <<  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 110)
   def _reduce_27(val, _values, result)
      result = val[0] >>  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 111)
   def _reduce_28(val, _values, result)
      result = val[1].minus()          ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 112)
   def _reduce_29(val, _values, result)
      result = val[0].ne  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 113)
   def _reduce_30(val, _values, result)
      result = val[0] ==  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 114)
   def _reduce_31(val, _values, result)
      result = val[0] >   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 115)
   def _reduce_32(val, _values, result)
      result = val[0] >=  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 116)
   def _reduce_33(val, _values, result)
      result = val[0] <   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 117)
   def _reduce_34(val, _values, result)
      result = val[0] <=  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 118)
   def _reduce_35(val, _values, result)
      result = val[1].not              ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 119)
   def _reduce_36(val, _values, result)
      result = val[0].and val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 120)
   def _reduce_37(val, _values, result)
      result = val[0].or  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 121)
   def _reduce_38(val, _values, result)
      result = val[0].set(val[2])      ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 122)
   def _reduce_39(val, _values, result)
      result = val[0].plus_set(val[2]) ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 123)
   def _reduce_40(val, _values, result)
      result = val[0].minus_set(val[2]); loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 124)
   def _reduce_41(val, _values, result)
      result = val[0].select(*val[2])  ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 125)
   def _reduce_42(val, _values, result)
      result = val[1].paren()          ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 133)
   def _reduce_43(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 134)
   def _reduce_44(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
 # reduce 45 omitted
 
 # reduce 46 omitted
 
 # reduce 47 omitted
 
 # reduce 48 omitted
 
 # reduce 49 omitted
 
 # reduce 50 omitted
 
 # reduce 51 omitted
 
 # reduce 52 omitted
 
 # reduce 53 omitted
 
 # reduce 54 omitted
 
 # reduce 55 omitted
 
 # reduce 56 omitted
 
 # reduce 57 omitted
 
 # reduce 58 omitted
 
 # reduce 59 omitted
 
 # reduce 60 omitted
 
 # reduce 61 omitted
 
 # reduce 62 omitted
 
 # reduce 63 omitted
 
 # reduce 64 omitted
 
 # reduce 65 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 166)
   def _reduce_66(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 167)
   def _reduce_67(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 175)
   def _reduce_68(val, _values, result)
           result = Factory.CALL_NAMED(val[0], true, val[2])
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 179)
   def _reduce_69(val, _values, result)
           result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 183)
   def _reduce_70(val, _values, result)
           result = Factory.CALL_NAMED(val[0], true, val[2])
       loc result, val[0], val[4]
       result.lambda = val[5]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 188)
   def _reduce_71(val, _values, result)
           result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
       result.lambda = val[3]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 192)
   def _reduce_72(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 197)
   def _reduce_73(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 198)
   def _reduce_74(val, _values, result)
      result = val[0]; val[0].lambda = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 201)
   def _reduce_75(val, _values, result)
      result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 202)
   def _reduce_76(val, _values, result)
      result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 203)
   def _reduce_77(val, _values, result)
      result = Factory.CALL_METHOD(val[0], []); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 208)
   def _reduce_78(val, _values, result)
             result = val[0].dot(Factory.fqn(val[2][:value]))
         loc result, val[1], val[2]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 220)
   def _reduce_79(val, _values, result)
           result = Factory.LAMBDA(val[0], val[1])
 #      loc result, val[1] # TODO
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 225)
   def _reduce_80(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 226)
   def _reduce_81(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 230)
   def _reduce_82(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 231)
   def _reduce_83(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 241)
   def _reduce_84(val, _values, result)
           result = val[1]
       loc(result, val[0], val[1])
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 248)
   def _reduce_85(val, _values, result)
             result = Factory.IF(val[0], Factory.block_or_expression(*val[2]), val[4])
         loc(result, val[0], (val[4] ? val[4] : val[3]))
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 252)
   def _reduce_86(val, _values, result)
             result = Factory.IF(val[0], nil, val[3])
         loc(result, val[0], (val[3] ? val[3] : val[2]))
       
     result
   end
 .,.,
 
 # reduce 87 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 260)
   def _reduce_88(val, _values, result)
             result = val[1]
         loc(result, val[0], val[1])
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 264)
   def _reduce_89(val, _values, result)
             result = Factory.block_or_expression(*val[2])
         loc result, val[0], val[3]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 268)
   def _reduce_90(val, _values, result)
             result = nil # don't think a nop is needed here either
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 277)
   def _reduce_91(val, _values, result)
           result = Factory.UNLESS(val[1], Factory.block_or_expression(*val[3]), val[5])
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 281)
   def _reduce_92(val, _values, result)
           result = Factory.UNLESS(val[1], nil, nil)
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 # reduce 93 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 291)
   def _reduce_94(val, _values, result)
             result = Factory.block_or_expression(*val[2])
         loc result, val[0], val[3]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 295)
   def _reduce_95(val, _values, result)
             result = nil # don't think a nop is needed here either
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 303)
   def _reduce_96(val, _values, result)
           result = Factory.CASE(val[1], *val[3])
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 309)
   def _reduce_97(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 310)
   def _reduce_98(val, _values, result)
      result = val[0].push val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 315)
   def _reduce_99(val, _values, result)
             result = Factory.WHEN(val[0], val[3])
         loc result, val[1], val[4]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 319)
   def _reduce_100(val, _values, result)
             result = Factory.WHEN(val[0], nil)
         loc result, val[1], val[3]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 323)
   def _reduce_101(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 # reduce 102 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 334)
   def _reduce_103(val, _values, result)
             result = val[1]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 339)
   def _reduce_104(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 340)
   def _reduce_105(val, _values, result)
      result = val[0].push val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 345)
   def _reduce_106(val, _values, result)
      result = Factory.MAP(val[0], val[2]) ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 357)
   def _reduce_107(val, _values, result)
           result = val[0]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 360)
   def _reduce_108(val, _values, result)
           result = case Factory.resource_shape(val[1])
       when :resource, :class
         tmp = Factory.RESOURCE(Factory.fqn(token_text(val[1])), val[3])
         tmp.form = val[0]
         tmp
       when :defaults
         error val[1], "A resource default can not be virtual or exported"
       when :override
         error val[1], "A resource override can not be virtual or exported"
       else
         error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[1], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 375)
   def _reduce_109(val, _values, result)
           result = case Factory.resource_shape(val[1])
       when :resource, :class, :defaults, :override
         error val[1], "Defaults are not virtualizable"
       else
         error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 383)
   def _reduce_110(val, _values, result)
           result = case Factory.resource_shape(val[0])
       when :resource, :class
         Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
       when :defaults
         error val[1], "A resource default can not specify a resource name"
       when :override
         error val[1], "A resource override does not allow override of name of resource"
       else
         error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 396)
   def _reduce_111(val, _values, result)
           result = case Factory.resource_shape(val[0])
       when :resource, :class
         # This catches deprecated syntax.
         error val[1], "All resource specifications require names"
       when :defaults
         Factory.RESOURCE_DEFAULTS(val[0], val[2])
       when :override
         # This was only done for override in original - TODO shuld it be here at all
         Factory.RESOURCE_OVERRIDE(val[0], val[2])
       else
         error val[0], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 411)
   def _reduce_112(val, _values, result)
             result = Factory.RESOURCE(Factory.fqn(token_text(val[1])), val[3])
         result.form = val[0]
         loc result, val[1], val[5]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 416)
   def _reduce_113(val, _values, result)
             result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
         loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 421)
   def _reduce_114(val, _values, result)
      result = Factory.RESOURCE_BODY(val[0], val[2]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 423)
   def _reduce_115(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 426)
   def _reduce_116(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 427)
   def _reduce_117(val, _values, result)
      result = val[0].push val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 432)
   def _reduce_118(val, _values, result)
      result = :virtual  
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 433)
   def _reduce_119(val, _values, result)
      result = :exported 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 434)
   def _reduce_120(val, _values, result)
      result = :exported 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 446)
   def _reduce_121(val, _values, result)
           result = Factory.COLLECT(val[0], val[1], val[3])
       loc result, val[0], val[5]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 450)
   def _reduce_122(val, _values, result)
           result = Factory.COLLECT(val[0], val[1], [])
       loc result, val[0], val[1]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 455)
   def _reduce_123(val, _values, result)
      result = Factory.VIRTUAL_QUERY(val[1])   ; loc result, val[0], val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 456)
   def _reduce_124(val, _values, result)
      result = Factory.EXPORTED_QUERY(val[1])  ; loc result, val[0], val[2] 
     result
   end
 .,.,
 
 # reduce 125 omitted
 
 # reduce 126 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 469)
   def _reduce_127(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 470)
   def _reduce_128(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 471)
   def _reduce_129(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
 # reduce 130 omitted
 
 # reduce 131 omitted
 
 # reduce 132 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 487)
   def _reduce_133(val, _values, result)
             result = Factory.ATTRIBUTE_OP(val[0][:value], :'=>', val[2])
         loc result, val[0], val[2]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 491)
   def _reduce_134(val, _values, result)
             result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
         loc result, val[0], val[2]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 501)
   def _reduce_135(val, _values, result)
           result = add_definition(Factory.DEFINITION(classname(val[1][:value]), val[2], val[4]))
       loc result, val[0], val[5]
       # New lexer does not keep track of this, this is done in validation
       if @lexer.respond_to?(:'indefine=')
         @lexer.indefine = false
       end
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 515)
   def _reduce_136(val, _values, result)
           # Remove this class' name from the namestack as all nested classes have been parsed
       namepop
       result = add_definition(Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5]))
       loc result, val[0], val[6]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 525)
   def _reduce_137(val, _values, result)
      namestack(val[0][:value]) ; result = val[0] 
     result
   end
 .,.,
 
 # reduce 138 omitted
 
 # reduce 139 omitted
 
 # reduce 140 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 534)
   def _reduce_141(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 # reduce 142 omitted
 
 # reduce 143 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 551)
   def _reduce_144(val, _values, result)
           result = add_definition(Factory.NODE(val[1], val[2], val[4]))
       loc result, val[0], val[5]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 555)
   def _reduce_145(val, _values, result)
           result = add_definition(Factory.NODE(val[1], val[2], nil))
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 565)
   def _reduce_146(val, _values, result)
      result = [result] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 566)
   def _reduce_147(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 571)
   def _reduce_148(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 572)
   def _reduce_149(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 573)
   def _reduce_150(val, _values, result)
      result = Factory.literal(:default); loc result, val[0] 
     result
   end
 .,.,
 
 # reduce 151 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 577)
   def _reduce_152(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 578)
   def _reduce_153(val, _values, result)
      result = Factory.concat(val[0], '.', val[2][:value]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
 # reduce 154 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 583)
   def _reduce_155(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 589)
   def _reduce_156(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 590)
   def _reduce_157(val, _values, result)
      error val[0], "'class' is not a valid classname" 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 594)
   def _reduce_158(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 595)
   def _reduce_159(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 596)
   def _reduce_160(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 600)
   def _reduce_161(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 601)
   def _reduce_162(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 605)
   def _reduce_163(val, _values, result)
      result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 606)
   def _reduce_164(val, _values, result)
      result = Factory.PARAM(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 619)
   def _reduce_165(val, _values, result)
      result = Factory.fqn(val[0][:value]).var ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 625)
   def _reduce_166(val, _values, result)
      result = Factory.LIST(val[1]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 626)
   def _reduce_167(val, _values, result)
      result = Factory.LIST(val[1]); loc result, val[0], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 627)
   def _reduce_168(val, _values, result)
      result = Factory.literal([]) ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 628)
   def _reduce_169(val, _values, result)
      result = Factory.LIST(val[1]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 629)
   def _reduce_170(val, _values, result)
      result = Factory.LIST(val[1]); loc result, val[0], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 630)
   def _reduce_171(val, _values, result)
      result = Factory.literal([]) ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 633)
   def _reduce_172(val, _values, result)
      result = Factory.HASH(val[1]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 634)
   def _reduce_173(val, _values, result)
      result = Factory.HASH(val[1]); loc result, val[0], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 635)
   def _reduce_174(val, _values, result)
      result = Factory.literal({}) ; loc result, val[0], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 638)
   def _reduce_175(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 639)
   def _reduce_176(val, _values, result)
      result = val[0].push val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 642)
   def _reduce_177(val, _values, result)
      result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] 
     result
   end
 .,.,
 
 # reduce 178 omitted
 
 # reduce 179 omitted
 
 # reduce 180 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 649)
   def _reduce_181(val, _values, result)
      result = Factory.literal(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 650)
   def _reduce_182(val, _values, result)
      result = Factory.string(val[0], *val[1]) ; loc result, val[0], val[1][-1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 651)
   def _reduce_183(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 652)
   def _reduce_184(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 653)
   def _reduce_185(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 654)
   def _reduce_186(val, _values, result)
      result = [val[0]] + val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 655)
   def _reduce_187(val, _values, result)
      result = Factory.TEXT(val[0]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 658)
   def _reduce_188(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 659)
   def _reduce_189(val, _values, result)
      result = [val[0]] + val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 663)
   def _reduce_190(val, _values, result)
      result = Factory.HEREDOC(val[0][:value], val[1]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 666)
   def _reduce_191(val, _values, result)
      result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 667)
   def _reduce_192(val, _values, result)
      result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 671)
   def _reduce_193(val, _values, result)
      result = Factory.EPP(val[1], val[2]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 674)
   def _reduce_194(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 675)
   def _reduce_195(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 676)
   def _reduce_196(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 679)
   def _reduce_197(val, _values, result)
      result = Factory.RENDER_STRING(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 680)
   def _reduce_198(val, _values, result)
      result = Factory.RENDER_EXPR(val[1]); loc result, val[0], val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 682)
   def _reduce_199(val, _values, result)
      result = Factory.NUMBER(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 683)
   def _reduce_200(val, _values, result)
      result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 684)
   def _reduce_201(val, _values, result)
      result = Factory.QREF(val[0][:value])  ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 685)
   def _reduce_202(val, _values, result)
      result = Factory.literal(:undef); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 686)
   def _reduce_203(val, _values, result)
      result = Factory.literal(:default); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 691)
   def _reduce_204(val, _values, result)
      result = Factory.literal(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 694)
   def _reduce_205(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
 # reduce 206 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 700)
   def _reduce_207(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
 # reduce 208 omitted
 
 # reduce 209 omitted
 
 # reduce 210 omitted
 
 # reduce 211 omitted
 
 # reduce 212 omitted
 
 # reduce 213 omitted
 
 # reduce 214 omitted
 
 # reduce 215 omitted
 
 # reduce 216 omitted
 
 # reduce 217 omitted
 
 # reduce 218 omitted
 
 # reduce 219 omitted
 
 # reduce 220 omitted
 
 # reduce 221 omitted
 
 # reduce 222 omitted
 
 # reduce 223 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 723)
   def _reduce_224(val, _values, result)
      result = nil
     result
   end
 .,.,
 
 def _reduce_none(val, _values, result)
   val[0]
 end
 
       end   # class Parser
       end   # module Parser
     end   # module Pops
   end   # module Puppet
diff --git a/lib/puppet/pops/parser/epp_parser.rb b/lib/puppet/pops/parser/epp_parser.rb
index 45e1b64bd..ea5415a56 100644
--- a/lib/puppet/pops/parser/epp_parser.rb
+++ b/lib/puppet/pops/parser/epp_parser.rb
@@ -1,51 +1,51 @@
 # The EppParser is a specialized Puppet Parser that starts parsing in Epp Text mode
 class Puppet::Pops::Parser::EppParser < Puppet::Pops::Parser::Parser
 
   # Initializes the epp parser support by creating a new instance of {Puppet::Pops::Parser::Lexer}
   # configured to start in Epp Lexing mode.
   # @return [void]
   #
   def initvars
-    self.lexer = Puppet::Pops::Parser::Lexer.new({:mode => :epp})
+    self.lexer = Puppet::Pops::Parser::Lexer2.new()# {:mode => :epp})
   end
 
   # Parses a file expected to contain epp text/DSL logic.
   def parse_file(file)
     unless FileTest.exist?(file)
       unless file =~ /\.epp$/
         file = file + ".epp"
       end
     end
     @lexer.file = file
     _parse()
   end
 
   # Performs the parsing and returns the resulting model.
   # The lexer holds state, and this is setup with {#parse_string}, or {#parse_file}.
   #
   # TODO: deal with options containing origin (i.e. parsing a string from externally known location).
   # TODO: should return the model, not a Hostclass
   #
   # @api private
   #
   def _parse()
     begin
       @yydebug = false
       main = yyparse(@lexer,:scan_epp)
       # #Commented out now because this hides problems in the racc grammar while developing
       # # TODO include this when test coverage is good enough.
       #      rescue Puppet::ParseError => except
       #        except.line ||= @lexer.line
       #        except.file ||= @lexer.file
       #        except.pos  ||= @lexer.pos
       #        raise except
       #      rescue => except
       #        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, @lexer.pos, except)
     end
     return main
   ensure
     @lexer.clear
     @namestack = []
     @definitions = []
   end
 end
diff --git a/lib/puppet/pops/parser/epp_support.rb b/lib/puppet/pops/parser/epp_support.rb
index 8209963f8..013297d60 100644
--- a/lib/puppet/pops/parser/epp_support.rb
+++ b/lib/puppet/pops/parser/epp_support.rb
@@ -1,244 +1,247 @@
 # This module is an integral part of the Lexer.
 # It handles scanning of EPP (Embedded Puppet), a form of string/expression interpolation similar to ERB.
 #
 require 'strscan'
 module Puppet::Pops::Parser::EppSupport
 
   TOKEN_RENDER_STRING = [:RENDER_STRING, nil, 0]
   TOKEN_RENDER_EXPR   = [:RENDER_EXPR, nil, 0]
 
   # Scans all of the content and returns it in an array
   # Note that the terminating [false, false] token is included in the result.
   #
   def fullscan_epp
     result = []
     scan_epp {|token, value| result.push([token, value]) }
     result
   end
 
   # A block must be passed to scan. It will be called with two arguments, a symbol for the token,
   # and an instance of LexerSupport::TokenValue
   # PERFORMANCE NOTE: The TokenValue is designed to reduce the amount of garbage / temporary data
   # and to only convert the lexer's internal tokens on demand. It is slightly more costly to create an
   # instance of a class defined in Ruby than an Array or Hash, but the gain is much bigger since transformation
   # logic is avoided for many of its members (most are never used (e.g. line/pos information which is only of
   # value in general for error messages, and for some expressions (which the lexer does not know about).
   #
   def scan_epp
     # PERFORMANCE note: it is faster to access local variables than instance variables.
     # This makes a small but notable difference since instance member access is avoided for
     # every token in the lexed content.
     #
     scn   = @scanner
     ctx   = @lexing_context
     queue = @token_queue
 
     lex_error "Internal Error: No string or file given to lexer to process." unless scn
 
     ctx[:epp_mode] = :text
+    enqueue_completed([:EPP_START, nil, 0], 0)
+
     interpolate_epp
 
     # This is the lexer's main loop
     until queue.empty? && scn.eos? do
       if token = queue.shift || lex_token
         yield [ ctx[:after] = token[0], token[1] ]
       end
     end
     if ctx[:epp_position]
       lex_error("Unbalanced epp tag, reached <eof> without closing tag.", ctx[:epp_position])
     end
 
     # Signals end of input
     yield [false, false]
   end
 
   def interpolate_epp(skip_leading=false)
     scn = @scanner
     ctx = @lexing_context
     eppscanner = EppScanner.new(scn)
     before = scn.pos
+
     s = eppscanner.scan(skip_leading)
 
     case eppscanner.mode
     when :text
       # Should be at end of scan, or something is terribly wrong
       lex_error("Internal error: template scanner returns text mode and is not and end of input") unless @scanner.eos?
       if s
         # s may be nil if scanned text ends with an epp tag (i.e. no trailing text).
         enqueue_completed([:RENDER_STRING, s, scn.pos - before], before)
       end
       ctx[:epp_open_position] = nil
       # do nothing else, scanner is at the end
 
     when :error
       lex_error(eppscanner.message())
 
     when :epp
       # It is meaningless to render empty string segments, and it is harmful to do this at
       # the start of the scan as it prevents specification of parameters with <%- ($x, $y) -%>
       #
       if s && s.length > 0
         enqueue_completed([:RENDER_STRING, s, scn.pos - before], before)
       end
       # switch epp_mode to general (embedded) pp logic (non rendered result)
       ctx[:epp_mode] = :epp
       ctx[:epp_open_position] = scn.pos
 
     when :expr
       # It is meaningless to render an empty string segment
       if s && s.length > 0
         enqueue_completed([:RENDER_STRING, s, scn.pos - before], before)
       end
       enqueue_completed(TOKEN_RENDER_EXPR, before)
       # switch mode to "epp expr interpolation"
       ctx[:epp_mode] = :expr
       ctx[:epp_open_position] = scn.pos
     else
       lex_error("Internal Error, Unknown mode #{eppscanner.mode} returned by template scanner")
     end
     nil
   end
 
   # A scanner specialized in processing text with embedded EPP (Embedded Puppet) tags.
   # The scanner is initialized with a StringScanner which it mutates as scanning takes place.
   # The intent is to use one instance of EppScanner per wanted scan, and this instance represents
   # the state after the scan.
   #
   # @example Sample usage
   #   a = "some text <% pp code %> some more text"
   #   scan = StringScanner.new(a)
   #   eppscan = EppScanner.new(scan)
   #   str = eppscan.scan
   #   eppscan.mode # => :epp
   #   eppscan.lines # => 0
   #   eppscan
   #
   # The scanner supports
   # * scanning text until <%, <%-, <%=
   # * while scanning text:
   #   * tokens <%% and %%> are translated to <% and %> respetively and is returned as text.
   #   * tokens <%# and %> (or ending with -%>) and the enclosed text is a comment and is not included in the returned text
   #   * text following a comment that ends with -%> gets trailing whitespace (up to and including a line break) trimmed
   #     and this whitespace is not included in the returned text.
   # * The continuation {#mode} is set to one of:
   #   * `:epp` - for a <% token
   #   * `:expr` - for a <%= token
   #   * `:text` - when there was no continuation mode (e.g. when input ends with text)
   #   * ':error` - if the tokens are unbalanced (reaching the end without a closing matching token). An error message
   #     is then also available via the method {#message}.
   #
   # Note that the intent is to use this specialized scanner to scan the text parts, when continuation mode is `:epp` or `:expr`
   # the pp lexer should advance scanning (using the string scanner) until it reaches and consumes a `-%>` or '%>´ token. If it
   # finds a `-%> token it should pass this on as a `skip_leading` parameter when it performs the next {#scan}.
   #
   class EppScanner
     # The original scanner used by the lexer/container using EppScanner
     attr_reader :scanner
 
     # The resulting mode after the scan.
     # The mode is one of `:text` (the initial mode), `:epp` embedded code (no output), `:expr` (embedded
     # expression), or `:error`
     #
     attr_reader :mode
 
     # An error message if `mode == :error`, `nil` otherwise.
     attr_reader :message
 
     # If the first scan should skip leading whitespace (typically detected by the pp lexer when the
     # pp mode end-token is found (i.e. `-%>`) and then passed on to the scanner.
     #
     attr_reader :skip_leading
 
     # Creates an EppScanner based on a StringScanner that represents the state where EppScanner should start scanning.
     # The given scanner will be mutated (i.e. position moved) to reflect the EppScanner's end state after a scan.
     #
     def initialize(scanner)
       @scanner = scanner
     end
 
     # Scans from the current position in the configured scanner, advances this scanner's position until the end
     # of the input, or to the first position after a mode switching token (`<%`, `<%-` or `<%=`). Number of processed
     # lines and continuation mode can be obtained via {#lines}, and {#mode}.
     #
     # @return [String, nil] the scanned and processed text, or nil if at the end of the input.
     #
     def scan(skip_leading=false)
       @mode = :text
       @skip_leading = skip_leading
 
       return nil if scanner.eos?
       s = ""
       until scanner.eos?
         part = @scanner.scan_until(/(<%)|\z/)
         if @skip_leading
           part.gsub!(/^[ \t]*\r?\n?/,'')
           @skip_leading = false
         end
         # The spec for %%> is to transform it into a literal %>. This is done here, as %%> otherwise would go
         # undetected in text mode. (i.e. it is not really necessary to escape %> with %%> in text mode unless
         # adding checks stating that a literal %> is illegal in text (unbalanced).
         #
         part.gsub!(/%%>/, '%>')
         s += part
         case @scanner.peek(1)
         when ""
           # at the end
           # if s ends with <% then this is an error (unbalanced <% %>)
           if s.end_with? "<%"
             @mode = :error
             @message = "Unbalanced embedded expression - opening <% and reaching end of input"
           else
             mode = :epp
           end
           return s
 
         when "-"
           # trim trailing whitespace on same line from accumulated s
           # return text and signal switch to pp mode
           @scanner.getch # drop the -
           s.gsub!(/\r?\n?[ \t]*<%\z/, '')
           @mode = :epp
           return s
 
         when "%"
           # verbatim text
           # keep the scanned <%, and continue scanning after skipping one %
           # (i.e. do nothing here)
           @scanner.getch # drop the % to get a literal <% in the output
 
         when "="
           # expression
           # return text and signal switch to expression mode
           # drop the scanned <%, and skip past -%>, or %>, but also skip %%>
           @scanner.getch # drop the =
           s.slice!(-2..-1)
           @mode = :expr
           return s
 
         when "#"
           # template comment
           # drop the scanned <%, and skip past -%>, or %>, but also skip %%>
           s.slice!(-2..-1)
 
           # unless there is an immediate termination i.e. <%#%> scan for the next %> that is not
           # preceded by a % (i.e. skip %%>)
           part = scanner.scan_until(/[^%]%>/)
           unless part
             @message = "Reaching end after opening <%# without seeing %>"
             @mode = :error
             return s
           end
           @skip_leading = true if part.end_with?("-%>")
           # Continue scanning for more text
 
         else
           # Switch to pp after having removed the <%
           s.slice!(-2..-1)
           @mode = :epp
           return s
         end
       end
     end
   end
 
 end
diff --git a/lib/puppet/pops/parser/lexer2.rb b/lib/puppet/pops/parser/lexer2.rb
index 7657cb7f0..8f24e2b33 100644
--- a/lib/puppet/pops/parser/lexer2.rb
+++ b/lib/puppet/pops/parser/lexer2.rb
@@ -1,676 +1,676 @@
 # The Lexer is responsbile for turning source text into tokens.
 # This version is a performance enhanced lexer (in comparison to the 3.x and earlier "future parser" lexer.
 #
 # Old returns tokens [:KEY, value, { locator = }
 # Could return [[token], locator]
 # or Token.new([token], locator) with the same API x[0] = token_symbol, x[1] = self, x[:key] = (:value, :file, :line, :pos) etc
 
 require 'strscan'
 require 'puppet/pops/parser/lexer_support'
 require 'puppet/pops/parser/heredoc_support'
 require 'puppet/pops/parser/interpolation_support'
 require 'puppet/pops/parser/epp_support'
 require 'puppet/pops/parser/slurp_support'
 
 class Puppet::Pops::Parser::Lexer2
   include Puppet::Pops::Parser::LexerSupport
   include Puppet::Pops::Parser::HeredocSupport
   include Puppet::Pops::Parser::InterpolationSupport
   include Puppet::Pops::Parser::SlurpSupport
   include Puppet::Pops::Parser::EppSupport
 
   # ALl tokens have three slots, the token name (a Symbol), the token text (String), and a token text length.
   # All operator and punctuation tokens reuse singleton arrays Tokens that require unique values create
   # a unique array per token.
   #
   # PEFORMANCE NOTES:
   # This construct reduces the amount of object that needs to be created for operators and punctuation.
   # The length is pre-calculated for all singleton tokens. The length is used both to signal the length of
   # the token, and to advance the scanner position (without having to advance it with a scan(regexp)).
   #
   TOKEN_LBRACK       = [:LBRACK,       '['.freeze,   1].freeze
   TOKEN_LISTSTART    = [:LISTSTART,    '['.freeze,   1].freeze
   TOKEN_RBRACK       = [:RBRACK,       ']'.freeze,   1].freeze
   TOKEN_LBRACE       = [:LBRACE,       '{'.freeze,   1].freeze
   TOKEN_RBRACE       = [:RBRACE,       '}'.freeze,   1].freeze
   TOKEN_SELBRACE     = [:SELBRACE,     '{'.freeze,   1].freeze
   TOKEN_LPAREN       = [:LPAREN,       '('.freeze,   1].freeze
   TOKEN_RPAREN       = [:RPAREN,       ')'.freeze,   1].freeze
 
   TOKEN_EQUALS       = [:EQUALS,       '='.freeze,   1].freeze
   TOKEN_APPENDS      = [:APPENDS,      '+='.freeze,  2].freeze
   TOKEN_DELETES      = [:DELETES,      '-='.freeze,  2].freeze
 
   TOKEN_ISEQUAL      = [:ISEQUAL,      '=='.freeze,  2].freeze
   TOKEN_NOTEQUAL     = [:NOTEQUAL,     '!='.freeze,  2].freeze
   TOKEN_MATCH        = [:MATCH,        '=~'.freeze,  2].freeze
   TOKEN_NOMATCH      = [:NOMATCH,      '!~'.freeze,  2].freeze
   TOKEN_GREATEREQUAL = [:GREATEREQUAL, '>='.freeze,  2].freeze
   TOKEN_GREATERTHAN  = [:GREATERTHAN,  '>'.freeze,   1].freeze
   TOKEN_LESSEQUAL    = [:LESSEQUAL,    '<='.freeze,  2].freeze
   TOKEN_LESSTHAN     = [:LESSTHAN,     '<'.freeze,   1].freeze
 
   TOKEN_FARROW       = [:FARROW,       '=>'.freeze,  2].freeze
   TOKEN_PARROW       = [:PARROW,       '+>'.freeze,  2].freeze
 
   TOKEN_LSHIFT       = [:LSHIFT,       '<<'.freeze,  2].freeze
   TOKEN_LLCOLLECT    = [:LLCOLLECT,    '<<|'.freeze, 3].freeze
   TOKEN_LCOLLECT     = [:LCOLLECT,     '<|'.freeze,  2].freeze
 
   TOKEN_RSHIFT       = [:RSHIFT,       '>>'.freeze,  2].freeze
   TOKEN_RRCOLLECT    = [:RRCOLLECT,    '|>>'.freeze, 3].freeze
   TOKEN_RCOLLECT     = [:RCOLLECT,     '|>'.freeze,  2].freeze
 
   TOKEN_PLUS         = [:PLUS,         '+'.freeze,   1].freeze
   TOKEN_MINUS        = [:MINUS,        '-'.freeze,   1].freeze
   TOKEN_DIV          = [:DIV,          '/'.freeze,   1].freeze
   TOKEN_TIMES        = [:TIMES,        '*'.freeze,   1].freeze
   TOKEN_MODULO       = [:MODULO,       '%'.freeze,   1].freeze
 
   TOKEN_NOT          = [:NOT,          '!'.freeze,   1].freeze
   TOKEN_DOT          = [:DOT,          '.'.freeze,   1].freeze
   TOKEN_PIPE         = [:PIPE,         '|'.freeze,   1].freeze
   TOKEN_AT           = [:AT ,          '@'.freeze,   1].freeze
   TOKEN_ATAT         = [:ATAT ,        '@@'.freeze,  2].freeze
   TOKEN_COLON        = [:COLON,        ':'.freeze,   1].freeze
   TOKEN_COMMA        = [:COMMA,        ','.freeze,   1].freeze
   TOKEN_SEMIC        = [:SEMIC,        ';'.freeze,   1].freeze
   TOKEN_QMARK        = [:QMARK,        '?'.freeze,   1].freeze
   TOKEN_TILDE        = [:TILDE,        '~'.freeze,   1].freeze # lexed but not an operator in Puppet
 
   TOKEN_REGEXP       = [:REGEXP,       nil,   0].freeze
 
   TOKEN_IN_EDGE      = [:IN_EDGE,      '->'.freeze,  2].freeze
   TOKEN_IN_EDGE_SUB  = [:IN_EDGE_SUB,  '~>'.freeze,  2].freeze
   TOKEN_OUT_EDGE     = [:OUT_EDGE,     '<-'.freeze,  2].freeze
   TOKEN_OUT_EDGE_SUB = [:OUT_EDGE_SUB, '<~'.freeze,  2].freeze
 
   # Tokens that are always unique to what has been lexed
   TOKEN_STRING         =  [:STRING, nil,          0].freeze
   TOKEN_DQPRE          =  [:DQPRE,  nil,          0].freeze
   TOKEN_DQMID          =  [:DQPRE,  nil,          0].freeze
   TOKEN_DQPOS          =  [:DQPRE,  nil,          0].freeze
   TOKEN_NUMBER         =  [:NUMBER, nil,          0].freeze
   TOKEN_VARIABLE       =  [:VARIABLE, nil,        1].freeze
   TOKEN_VARIABLE_EMPTY =  [:VARIABLE, ''.freeze,  1].freeze
 
-  # Tokens that start HEREDOC and EPP, both have syntax as an argument.
-  # These tokens are always unique to what has been lexed.
-  #
+  # HEREDOC has syntax as an argument.
   TOKEN_HEREDOC        =  [:HEREDOC, nil, 0].freeze
-  TOKEN_EPPSTART       =  [:EPPSTART, nil, 0].freeze
+
+  # EPP_START is currently a marker token, may later get syntax
+  TOKEN_EPPSTART       =  [:EPP_START, nil, 0].freeze
 
   # This is used for unrecognized tokens, will always be a single character. This particular instance
   # is not used, but is kept here for documentation purposes.
   TOKEN_OTHER        = [:OTHER,  nil,  0]
 
   # Keywords are all singleton tokens with pre calculated lengths.
   # Booleans are pre-calculated (rather than evaluating the strings "false" "true" repeatedly.
   #
   KEYWORDS = {
     "case"     => [:CASE,    'case',     4],
     "class"    => [:CLASS,   'class',    5],
     "default"  => [:DEFAULT, 'default',  7],
     "define"   => [:DEFINE,  'define',   6],
     "if"       => [:IF,      'if',       2],
     "elsif"    => [:ELSIF,   'elsif',    5],
     "else"     => [:ELSE,    'else',     4],
     "inherits" => [:INHERITS,'inherits', 8],
     "node"     => [:NODE,    'node',     4],
     "and"      => [:AND,     'and',      3],
     "or"       => [:OR,      'or',       2],
     "undef"    => [:UNDEF,   'undef',    5],
     "false"    => [:BOOLEAN, false,      5],
     "true"     => [:BOOLEAN, true,       4],
     "in"       => [:IN,      'in',       2],
     "unless"   => [:UNLESS,  'unless',   6],
   }
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }
   KEYWORDS.freeze
 
   # Reverse lookup of keyword name to string
   KEYWORD_NAMES = {}
   KEYWORDS.each {|k, v| KEYWORD_NAMES[v[0]] = k }
   KEYWORD_NAMES.freeze
 
   PATTERN_WS        = %r{[[:blank:]\r]+}
 
   # The single line comment includes the line ending.
   PATTERN_COMMENT   = %r{#.*\r?}
   PATTERN_MLCOMMENT = %r{/\*(.*?)\*/}m
 
   PATTERN_REGEX     = %r{/[^/\n]*/}
   PATTERN_REGEX_END = %r{/}
   PATTERN_REGEX_A   = %r{\A/} # for replacement to ""
   PATTERN_REGEX_Z   = %r{/\Z} # for replacement to ""
   PATTERN_REGEX_ESC = %r{\\/} # for replacement to "/"
 
   # The 3x patterns:
   # PATTERN_CLASSREF       = %r{((::){0,1}[A-Z][-\w]*)+}
   # PATTERN_NAME           = %r{((::)?[a-z0-9][-\w]*)(::[a-z0-9][-\w]*)*}
 
   # The NAME and CLASSREF in 4x are strict. Each segment must start with
   # a letter a-z and may not contain dashes (\w includes letters, digits and _).
   #
   PATTERN_CLASSREF       = %r{((::){0,1}[A-Z][\w]*)+}
   PATTERN_NAME           = %r{((::)?[a-z][\w]*)(::[a-z][\w]*)*}
   PATTERN_BARE_WORD      = %r{[a-z_](?:[\w-]*[\w])?}
 
   PATTERN_DOLLAR_VAR     = %r{\$(::)?(\w+::)*\w+}
   PATTERN_NUMBER         = %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b}
 
   # PERFORMANCE NOTE:
   # Comparison against a frozen string is faster (than unfrozen).
   #
   STRING_BSLASH_BSLASH = '\\'.freeze
 
   attr_reader :locator
 
   def initialize()
   end
 
   # Clears the lexer state (it is not required to call this as it will be garbage collected
   # and the next lex call (lex_string, lex_file) will reset the internal state.
   #
   def clear()
     # not really needed, but if someone wants to ensure garbage is collected as early as possible
     @scanner = nil
     @locator = nil
     @lexing_context = nil
   end
 
   # Convenience method, and for compatibility with older lexer. Use the lex_string instead which allows
   # passing the path to use without first having to call file= (which reads the file if it exists).
   # (Bad form to use overloading of assignment operator for something that is not really an assignment. Also,
   # overloading of = does not allow passing more than one argument).
   #
   def string=(string)
     lex_string(string, '')
   end
 
   def lex_string(string, path='')
     initvars
     @scanner = StringScanner.new(string)
     @locator = Puppet::Pops::Parser::Locator.locator(string, path)
   end
 
   # Lexes an unquoted string.
   # @param string [String] the string to lex
   # @param locator [Puppet::Pops::Parser::Locator] the locator to use (a default is used if nil is given)
   # @param escapes [Array<String>] array of character strings representing the escape sequences to transform
   # @param interpolate [Boolean] whether interpolation of expressions should be made or not.
   #
   def lex_unquoted_string(string, locator, escapes, interpolate)
     initvars
     @scanner = StringScanner.new(string)
     @locator = locator || Puppet::Pops::Parser::Locator.locator(string, '')
     @lexing_context[:escapes] = escapes || UQ_ESCAPES
     @lexing_context[:uq_slurp_pattern] = (interpolate || !escapes.empty?) ? SLURP_UQ_PATTERN : SLURP_ALL_PATTERN
   end
 
   # Convenience method, and for compatibility with older lexer. Use the lex_file instead.
   # (Bad form to use overloading of assignment operator for something that is not really an assignment).
   #
   def file=(file)
     lex_file(file)
   end
 
   # TODO: This method should not be used, callers should get the locator since it is most likely required to
   # compute line, position etc given offsets.
   #
   def file
     @locator ? @locator.file : nil
   end
 
   # Initializes lexing of the content of the given file. An empty string is used if the file does not exist.
   #
   def lex_file(file)
     initvars
     contents = Puppet::FileSystem.exist?(file) ? Puppet::FileSystem.read(file) : ""
     @scanner = StringScanner.new(contents.freeze)
     @locator = Puppet::Pops::Parser::Locator.locator(contents, file)
   end
 
   def initvars
     @token_queue = []
     # NOTE: additional keys are used; :escapes, :uq_slurp_pattern, :newline_jump, :epp_*
     @lexing_context = {
       :brace_count => 0,
       :after => nil,
     }
   end
 
   # Scans all of the content and returns it in an array
   # Note that the terminating [false, false] token is included in the result.
   #
   def fullscan
     result = []
     scan {|token, value| result.push([token, value]) }
     result
   end
 
   # A block must be passed to scan. It will be called with two arguments, a symbol for the token,
   # and an instance of LexerSupport::TokenValue
   # PERFORMANCE NOTE: The TokenValue is designed to reduce the amount of garbage / temporary data
   # and to only convert the lexer's internal tokens on demand. It is slightly more costly to create an
   # instance of a class defined in Ruby than an Array or Hash, but the gain is much bigger since transformation
   # logic is avoided for many of its members (most are never used (e.g. line/pos information which is only of
   # value in general for error messages, and for some expressions (which the lexer does not know about).
   #
   def scan
     # PERFORMANCE note: it is faster to access local variables than instance variables.
     # This makes a small but notable difference since instance member access is avoided for
     # every token in the lexed content.
     #
     scn   = @scanner
     ctx   = @lexing_context
     queue = @token_queue
 
     lex_error_without_pos("Internal Error: No string or file given to lexer to process.") unless scn
 
     scn.skip(PATTERN_WS)
 
     # This is the lexer's main loop
     until queue.empty? && scn.eos? do
       if token = queue.shift || lex_token
         yield [ ctx[:after] = token[0], token[1] ]
       end
     end
 
     # Signals end of input
     yield [false, false]
   end
 
   # This lexes one token at the current position of the scanner.
   # PERFORMANCE NOTE: Any change to this logic should be performance measured.
   #
   def lex_token
     # Using three char look ahead (may be faster to do 2 char look ahead since only 2 tokens require a third
     scn = @scanner
     ctx = @lexing_context
     before = @scanner.pos
 
     # A look ahead of 3 characters is used since the longest operator ambiguity is resolved at that point.
     # PERFORMANCE NOTE: It is faster to peek once and use three separate variables for lookahead 0, 1 and 2.
     #
     la = scn.peek(3)
     return nil if la.empty?
 
     # Ruby 1.8.7 requires using offset and length (or integers are returned.
     # PERFORMANCE NOTE.
     # It is slightly faster to use these local variables than accessing la[0], la[1] etc. in ruby 1.9.3
     # But not big enough to warrant two completely different implementations.
     #
     la0 = la[0,1]
     la1 = la[1,1]
     la2 = la[2,1]
 
     # PERFORMANCE NOTE:
     # A case when, where all the cases are literal values is the fastest way to map from data to code.
     # It is much faster than using a hash with lambdas, hash with symbol used to then invoke send etc.
     # This case statement is evaluated for most character positions in puppet source, and great care must
     # be taken to not introduce performance regressions.
     #
     case la0
 
     when '.'
       emit(TOKEN_DOT, before)
 
     when ','
       emit(TOKEN_COMMA, before)
 
     when '['
       if ctx[:after] == :NAME && (before == 0 || scn.string[before-1,1] =~ /[[:blank:]\r\n]+/)
         emit(TOKEN_LISTSTART, before)
       else
         emit(TOKEN_LBRACK, before)
       end
 
     when ']'
       emit(TOKEN_RBRACK, before)
 
     when '('
       emit(TOKEN_LPAREN, before)
 
     when ')'
       emit(TOKEN_RPAREN, before)
 
     when ';'
       emit(TOKEN_SEMIC, before)
 
     when '?'
       emit(TOKEN_QMARK, before)
 
     when '*'
       emit(TOKEN_TIMES, before)
 
     when '%'
       if la1 == '>' && ctx[:epp_mode]
         scn.pos += 2
         ctx[:epp_mode] = :text
         interpolate_epp
       else
         emit(TOKEN_MODULO, before)
       end
 
     when '{'
       # The lexer needs to help the parser since the technology used cannot deal with
       # lookahead of same token with different precedence. This is solved by making left brace
       # after ? into a separate token.
       #
       ctx[:brace_count] += 1
       emit(if ctx[:after] == :QMARK
         TOKEN_SELBRACE
       else
         TOKEN_LBRACE
       end, before)
 
     when '}'
       ctx[:brace_count] -= 1
       emit(TOKEN_RBRACE, before)
 
       # TOKENS @, @@, @(
     when '@'
       case la1
       when '@'
         emit(TOKEN_ATAT, before) # TODO; Check if this is good for the grammar
       when '('
         heredoc
       else
         emit(TOKEN_AT, before)
       end
 
       # TOKENS |, |>, |>>
     when '|'
       emit(case la1
       when '>'
         la2 == '>' ? TOKEN_RRCOLLECT : TOKEN_RCOLLECT
       else
         TOKEN_PIPE
       end, before)
 
       # TOKENS =, =>, ==, =~
     when '='
       emit(case la1
       when '='
         TOKEN_ISEQUAL
       when '>'
         TOKEN_FARROW
       when '~'
         TOKEN_MATCH
       else
         TOKEN_EQUALS
       end, before)
 
       # TOKENS '+', '+=', and '+>'
     when '+'
       emit(case la1
       when '='
         TOKEN_APPENDS
       when '>'
         TOKEN_PARROW
       else
         TOKEN_PLUS
       end, before)
 
       # TOKENS '-', '->', and epp '-%>' (end of interpolation with trim)
     when '-'
       if ctx[:epp_mode] && la1 == '%' && la2 == '>'
         scn.pos += 3
         interpolate_epp(:with_trim)
       else
         emit(case la1
         when '>'
           TOKEN_IN_EDGE
         when '='
           TOKEN_DELETES
         else
           TOKEN_MINUS
         end, before)
       end
 
       # TOKENS !, !=, !~
     when '!'
       emit(case la1
       when '='
         TOKEN_NOTEQUAL
       when '~'
         TOKEN_NOMATCH
       else
         TOKEN_NOT
       end, before)
 
       # TOKENS ~>, ~
     when '~'
       emit(la1 == '>' ? TOKEN_IN_EDGE_SUB : TOKEN_TILDE, before)
 
     when '#'
       scn.skip(PATTERN_COMMENT)
       nil
 
       # TOKENS '/', '/*' and '/ regexp /'
     when '/'
       case la1
       when '*'
         scn.skip(PATTERN_MLCOMMENT)
         nil
 
       else
         # regexp position is a regexp, else a div
         if regexp_acceptable? && value = scn.scan(PATTERN_REGEX)
           # Ensure an escaped / was not matched
           while value[-2..-2] == STRING_BSLASH_BSLASH # i.e. \\
             value += scn.scan_until(PATTERN_REGEX_END)
           end
           regex = value.sub(PATTERN_REGEX_A, '').sub(PATTERN_REGEX_Z, '').gsub(PATTERN_REGEX_ESC, '/')
           emit_completed([:REGEX, Regexp.new(regex), scn.pos-before], before)
         else
           emit(TOKEN_DIV, before)
         end
       end
 
       # TOKENS <, <=, <|, <<|, <<, <-, <~
     when '<'
       emit(case la1
       when '<'
         if la2 == '|'
           TOKEN_LLCOLLECT
         else
           TOKEN_LSHIFT
         end
       when '='
         TOKEN_LESSEQUAL
       when '|'
         TOKEN_LCOLLECT
       when '-'
         TOKEN_OUT_EDGE
       when '~'
         TOKEN_OUT_EDGE_SUB
       else
         TOKEN_LESSTHAN
       end, before)
 
       # TOKENS >, >=, >>
     when '>'
       emit(case la1
       when '>'
         TOKEN_RSHIFT
       when '='
         TOKEN_GREATEREQUAL
       else
         TOKEN_GREATERTHAN
       end, before)
 
       # TOKENS :, ::CLASSREF, ::NAME
     when ':'
       if la1 == ':'
         before = scn.pos
         # PERFORMANCE NOTE: This could potentially be speeded up by using a case/when listing all
         # upper case letters. Alternatively, the 'A', and 'Z' comparisons may be faster if they are
         # frozen.
         #
         if la2 >= 'A' && la2 <= 'Z'
           # CLASSREF or error
           value = scn.scan(PATTERN_CLASSREF)
           if value
             after = scn.pos
             emit_completed([:CLASSREF, value, after-before], before)
           else
             # move to faulty position ('::<uc-letter>' was ok)
             scn.pos = scn.pos + 3
             lex_error("Illegal fully qualified class reference")
           end
         else
           # NAME or error
           value = scn.scan(PATTERN_NAME)
           if value
             emit_completed([:NAME, value, scn.pos-before], before)
           else
             # move to faulty position ('::' was ok)
             scn.pos = scn.pos + 2
             lex_error("Illegal fully qualified name")
           end
         end
       else
         emit(TOKEN_COLON, before)
       end
 
     when '$'
       if value = scn.scan(PATTERN_DOLLAR_VAR)
         emit_completed([:VARIABLE, value[1..-1], scn.pos - before], before)
       else
         # consume the $ and let higher layer complain about the error instead of getting a syntax error
         emit(TOKEN_VARIABLE_EMPTY, before)
       end
 
     when '"'
       # Recursive string interpolation, 'interpolate' either returns a STRING token, or
       # a DQPRE with the rest of the string's tokens placed in the @token_queue
       interpolate_dq
 
     when "'"
       emit_completed([:STRING, slurp_sqstring, before-scn.pos], before)
 
     when '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
       value = scn.scan(PATTERN_NUMBER)
       if value
         length = scn.pos - before
         assert_numeric(value, length)
         emit_completed([:NUMBER, value, length], before)
       else
         # move to faulty position ([0-9] was ok)
         scn.pos = scn.pos + 1
         lex_error("Illegal number")
       end
 
     when 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
       value = scn.scan(PATTERN_NAME)
       # NAME or false start because followed by hyphen(s) and word
       if value && !scn.match?(/-+\w/)
         emit_completed(KEYWORDS[value] || [:NAME, value, scn.pos - before], before)
       else
         # Restart and check entire pattern (for ease of detecting non allowed trailing hyphen)
         scn.pos = before
         value = scn.scan(PATTERN_BARE_WORD)
         if value
           emit_completed([:STRING, value, scn.pos - before], before)
         else
           # move to faulty position ([a-z] was ok)
           scn.pos = scn.pos + 1
           lex_error("Illegal name")
         end
       end
 
     when 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
     'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
       value = scn.scan(PATTERN_CLASSREF)
       if value
         emit_completed([:CLASSREF, value, scn.pos - before], before)
       else
         # move to faulty position ([A-Z] was ok)
         scn.pos = scn.pos + 1
         lex_error("Illegal class reference")
       end
 
     when "\n"
       # If heredoc_cont is in effect there are heredoc text lines to skip over
       # otherwise just skip the newline.
       #
       if ctx[:newline_jump]
         scn.pos = ctx[:newline_jump]
         ctx[:newline_jump] = nil
       else
         scn.pos += 1
       end
       return nil
 
     when ' ', "\t", "\r"
       scn.skip(PATTERN_WS)
       return nil
 
     else
       # In case of unicode spaces of various kinds that are captured by a regexp, but not by the
       # simpler case expression above (not worth handling those special cases with better performance).
       if scn.skip(PATTERN_WS)
         nil
       else
         # "unrecognized char"
         emit([:OTHER, la0, 1], before)
       end
     end
   end
 
   # Emits (produces) a token [:tokensymbol, TokenValue] and moves the scanner's position past the token
   #
   def emit(token, byte_offset)
     @scanner.pos = byte_offset + token[2]
     [token[0], TokenValue.new(token, byte_offset, @locator)]
   end
 
   # Emits the completed token on the form [:tokensymbol, TokenValue. This method does not alter
   # the scanner's position.
   #
   def emit_completed(token, byte_offset)
     [token[0], TokenValue.new(token, byte_offset, @locator)]
   end
 
   # Enqueues a completed token at the given offset
   def enqueue_completed(token, byte_offset)
     @token_queue << emit_completed(token, byte_offset)
   end
 
   # Allows subprocessors for heredoc etc to enqueue tokens that are tokenized by a different lexer instance
   #
   def enqueue(emitted_token)
     @token_queue << emitted_token
   end
 
   # Answers after which tokens it is acceptable to lex a regular expression.
   # PERFORMANCE NOTE:
   # It may be beneficial to turn this into a hash with default value of true for missing entries.
   # A case expression with literal values will however create a hash internally. Since a reference is
   # always needed to the hash, this access is almost as costly as a method call.
   #
   def regexp_acceptable?
     case @lexing_context[:after]
 
     # Ends of (potential) R-value generating expressions
     when :RPAREN, :RBRACK, :RRCOLLECT, :RCOLLECT
       false
 
     # End of (potential) R-value - but must be allowed because of case expressions
     # Called out here to not be mistaken for a bug.
     when :RBRACE
       true
 
     # Operands (that can be followed by DIV (even if illegal in grammar)
     when :NAME, :CLASSREF, :NUMBER, :STRING, :BOOLEAN, :DQPRE, :DQMID, :DQPOST, :HEREDOC, :REGEX
       false
 
     else
       true
     end
   end
 
 end
diff --git a/spec/unit/pops/parser/lexer2_spec.rb b/spec/unit/pops/parser/lexer2_spec.rb
index e07d3722c..ae6099223 100644
--- a/spec/unit/pops/parser/lexer2_spec.rb
+++ b/spec/unit/pops/parser/lexer2_spec.rb
@@ -1,408 +1,413 @@
 require 'spec_helper'
 require 'matchers/match_tokens2'
 require 'puppet/pops'
 require 'puppet/pops/parser/lexer2'
 
 module EgrammarLexer2Spec
   def tokens_scanned_from(s)
     lexer = Puppet::Pops::Parser::Lexer2.new
     lexer.string = s
     tokens = lexer.fullscan[0..-2]
   end
 
   def epp_tokens_scanned_from(s)
     lexer = Puppet::Pops::Parser::Lexer2.new
     lexer.string = s
     tokens = lexer.fullscan_epp[0..-2]
   end
 end
 
 describe 'Lexer2' do
   include EgrammarLexer2Spec
 
   {
     :LBRACK => '[',
     :RBRACK => ']',
     :LBRACE => '{',
     :RBRACE => '}',
     :LPAREN => '(',
     :RPAREN => ')',
     :EQUALS => '=',
     :ISEQUAL => '==',
     :GREATEREQUAL => '>=',
     :GREATERTHAN => '>',
     :LESSTHAN => '<',
     :LESSEQUAL => '<=',
     :NOTEQUAL => '!=',
     :NOT => '!',
     :COMMA => ',',
     :DOT => '.',
     :COLON => ':',
     :AT => '@',
     :LLCOLLECT => '<<|',
     :RRCOLLECT => '|>>',
     :LCOLLECT => '<|',
     :RCOLLECT => '|>',
     :SEMIC => ';',
     :QMARK => '?',
     :OTHER => '\\',
     :FARROW => '=>',
     :PARROW => '+>',
     :APPENDS => '+=',
     :DELETES => '-=',
     :PLUS => '+',
     :MINUS => '-',
     :DIV => '/',
     :TIMES => '*',
     :LSHIFT => '<<',
     :RSHIFT => '>>',
     :MATCH => '=~',
     :NOMATCH => '!~',
     :IN_EDGE => '->',
     :OUT_EDGE => '<-',
     :IN_EDGE_SUB => '~>',
     :OUT_EDGE_SUB => '<~',
     :PIPE => '|',
   }.each do |name, string|
     it "should lex a token named #{name.to_s}" do
       tokens_scanned_from(string).should match_tokens2(name)
     end
   end
 
   {
     "case"     => :CASE,
     "class"    => :CLASS,
     "default"  => :DEFAULT,
     "define"   => :DEFINE,
 #    "import" => :IMPORT, # done as a function in egrammar
     "if"       => :IF,
     "elsif"    => :ELSIF,
     "else"     => :ELSE,
     "inherits" => :INHERITS,
     "node"     => :NODE,
     "and"      => :AND,
     "or"       => :OR,
     "undef"    => :UNDEF,
     "false"    => :BOOLEAN,
     "true"     => :BOOLEAN,
     "in"       => :IN,
     "unless"   => :UNLESS,
   }.each do |string, name|
     it "should lex a keyword from '#{string}'" do
       tokens_scanned_from(string).should match_tokens2(name)
     end
   end
 
   # TODO: Complete with all edge cases
   [ 'A', 'A::B', '::A', '::A::B',].each do |string|
     it "should lex a CLASSREF on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:CLASSREF, string])
     end
   end
 
   # TODO: Complete with all edge cases
   [ 'a', 'a::b', '::a', '::a::b',].each do |string|
     it "should lex a NAME on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NAME, string])
     end
   end
 
   [ 'a-b', 'a--b', 'a-b-c'].each do |string|
     it "should lex a BARE WORD STRING on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:STRING, string])
     end
   end
 
   { '-a'   =>      [:MINUS, :NAME],
     '--a'  =>      [:MINUS, :MINUS, :NAME],
     'a-'   =>      [:NAME, :MINUS],
     'a- b'   =>    [:NAME, :MINUS, :NAME],
     'a--'  =>      [:NAME, :MINUS, :MINUS],
     'a-$3' =>      [:NAME, :MINUS, :VARIABLE],
   }.each do |source, expected|
     it "should lex leading and trailing hyphens from #{source}" do
       tokens_scanned_from(source).should match_tokens2(*expected)
     end
   end
 
   { 'false'=>false, 'true'=>true}.each do |string, value|
     it "should lex a BOOLEAN on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:BOOLEAN, value])
     end
   end
 
   [ '0', '1', '2982383139'].each do |string|
     it "should lex a decimal integer NUMBER on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
     end
   end
 
   { ' 1' => '1', '1 ' => '1', ' 1 ' => '1'}.each do |string, value|
     it "should lex a NUMBER with surrounding space '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, value])
     end
   end
 
   [ '0.0', '0.1', '0.2982383139', '29823.235', '10e23', '10e-23', '1.234e23'].each do |string|
     it "should lex a decimal floating point NUMBER on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
     end
   end
 
   [ '00', '01', '0123', '0777'].each do |string|
     it "should lex an octal integer NUMBER on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
     end
   end
 
   [ '0x0', '0x1', '0xa', '0xA', '0xabcdef', '0xABCDEF'].each do |string|
     it "should lex an hex integer NUMBER on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
     end
   end
 
   { "''"      => '',
     "'a'"     => 'a',
     "'a\\'b'" =>"a'b",
     "'a\\rb'" =>"a\\rb",
     "'a\\nb'" =>"a\\nb",
     "'a\\tb'" =>"a\\tb",
     "'a\\sb'" =>"a\\sb",
     "'a\\$b'" =>"a\\$b",
     "'a\\\"b'" =>"a\\\"b",
     "'a\\\\b'" =>"a\\b",
     "'a\\\\'" =>"a\\",
   }.each do |source, expected|
     it "should lex a single quoted STRING on the form #{source}" do
       tokens_scanned_from(source).should match_tokens2([:STRING, expected])
     end
   end
 
   { '""'      => '',
     '"a"'     => 'a',
     '"a\'b"'  => "a'b",
   }.each do |source, expected|
     it "should lex a double quoted STRING on the form #{source}" do
       tokens_scanned_from(source).should match_tokens2([:STRING, expected])
     end
   end
 
   { '"a$x b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
                    [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
                    [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
 
     '"a$x.b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
                    [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
                    [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
 
     '"$x.b"'   => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
                    [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
                    [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
 
     '"a$x"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
                    [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
                    [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
   }.each do |source, expected|
     it "should lex an interpolated variable 'x' from #{source}" do
       tokens_scanned_from(source).should match_tokens2(*expected)
     end
   end
 
   it "differentiates between foo[x] and foo [x] (whitespace)" do
     tokens_scanned_from("$a[1]").should match_tokens2(:VARIABLE, :LBRACK, :NUMBER, :RBRACK)
     tokens_scanned_from("$a [1]").should match_tokens2(:VARIABLE, :LBRACK, :NUMBER, :RBRACK)
     tokens_scanned_from("a[1]").should match_tokens2(:NAME, :LBRACK, :NUMBER, :RBRACK)
     tokens_scanned_from("a [1]").should match_tokens2(:NAME, :LISTSTART, :NUMBER, :RBRACK)
     tokens_scanned_from(" if \n\r\t\nif if ").should match_tokens2(:IF, :IF, :IF)
   end
 
   it "skips whitepsace" do
     tokens_scanned_from(" if if if ").should match_tokens2(:IF, :IF, :IF)
     tokens_scanned_from(" if \n\r\t\nif if ").should match_tokens2(:IF, :IF, :IF)
   end
 
   it "skips single line comments" do
     tokens_scanned_from("if # comment\nif").should match_tokens2(:IF, :IF)
   end
 
   ["if /* comment */\nif",
     "if /* comment\n */\nif",
     "if /*\n comment\n */\nif",
     ].each do |source|
     it "skips multi line comments" do
       tokens_scanned_from(source).should match_tokens2(:IF, :IF)
     end
   end
 
   { "=~" => [:MATCH, "=~ /./"],
     "!~" => [:NOMATCH, "!~ /./"],
     ","  => [:COMMA, ", /./"],
     "("  => [:LPAREN, "( /./"],
     "["  => [:LBRACK, "[ /./"],
     "{"  => [:LBRACE, "{ /./"],
     "+"  => [:PLUS, "+ /./"],
     "-"  => [:MINUS, "- /./"],
     "*"  => [:TIMES, "* /./"],
     ";"  => [:SEMIC, "; /./"],
   }.each do |token, entry|
     it "should lex regexp after '#{token}'" do
       tokens_scanned_from(entry[1]).should match_tokens2(entry[0], :REGEX)
     end
   end
 
   it "should lex a simple expression" do
     tokens_scanned_from('1 + 1').should match_tokens2([:NUMBER, '1'], :PLUS, [:NUMBER, '1'])
   end
 
   { "1"     => ["1 /./",       [:NUMBER, :DIV, :DOT, :DIV]],
     "'a'"   => ["'a' /./",     [:STRING, :DIV, :DOT, :DIV]],
     "true"  => ["true /./",    [:BOOLEAN, :DIV, :DOT, :DIV]],
     "false" => ["false /./",   [:BOOLEAN, :DIV, :DOT, :DIV]],
     "/./"   => ["/./ /./",     [:REGEX, :DIV, :DOT, :DIV]],
     "a"     => ["a /./",       [:NAME, :DIV, :DOT, :DIV]],
     "A"     => ["A /./",       [:CLASSREF, :DIV, :DOT, :DIV]],
     ")"     => [") /./",       [:RPAREN, :DIV, :DOT, :DIV]],
     "]"     => ["] /./",       [:RBRACK, :DIV, :DOT, :DIV]],
     "|>"     => ["|> /./",     [:RCOLLECT, :DIV, :DOT, :DIV]],
     "|>>"    => ["|>> /./",    [:RRCOLLECT, :DIV, :DOT, :DIV]],
     '"a$a"'  => ['"a$a" /./',  [:DQPRE, :VARIABLE, :DQPOST, :DIV, :DOT, :DIV]],
   }.each do |token, entry|
     it "should not lex regexp after '#{token}'" do
       tokens_scanned_from(entry[ 0 ]).should match_tokens2(*entry[ 1 ])
     end
   end
 
   it 'should lex assignment' do
     tokens_scanned_from("$a = 10").should match_tokens2([:VARIABLE, "a"], :EQUALS, [:NUMBER, '10'])
   end
 
 # TODO: Tricky, and heredoc not supported yet
 #  it "should not lex regexp after heredoc" do
 #    tokens_scanned_from("1 / /./").should match_tokens2(:NUMBER, :DIV, :REGEX)
 #  end
 
   it "should lex regexp at beginning of input" do
     tokens_scanned_from(" /./").should match_tokens2(:REGEX)
   end
 
   it "should lex regexp right of div" do
     tokens_scanned_from("1 / /./").should match_tokens2(:NUMBER, :DIV, :REGEX)
   end
 
   context 'when lexer lexes heredoc' do
     it 'lexes tag, syntax and escapes, margin and right trim' do
       code = <<-CODE
       @(END:syntax/t)
       Tex\\tt\\n
       |- END
       CODE
       tokens_scanned_from(code).should match_tokens2([:HEREDOC, 'syntax'], :SUBLOCATE, [:STRING, "Tex\tt\\n"])
     end
 
     it 'lexes "tag", syntax and escapes, margin, right trim and interpolation' do
       code = <<-CODE
       @("END":syntax/t)
       Tex\\tt\\n$var After
       |- END
       CODE
       tokens_scanned_from(code).should match_tokens2(
         [:HEREDOC, 'syntax'],
         :SUBLOCATE,
         [:DQPRE, "Tex\tt\\n"],
         [:VARIABLE, "var"],
         [:DQPOST, " After"]
         )
     end
   end
 
   it 'should support unicode characters' do
     code = <<-CODE
     "x\\u2713y"
     CODE
     if Puppet::Pops::Parser::Locator::RUBYVER < Puppet::Pops::Parser::Locator::RUBY_1_9_3
       # Ruby 1.8.7 reports the multibyte char as several octal characters
       tokens_scanned_from(code).should match_tokens2([:STRING, "x\342\234\223y"])
     else
       # >= Ruby 1.9.3 reports \u
       tokens_scanned_from(code).should match_tokens2([:STRING, "x\u2713y"])
     end
   end
 
   context 'when lexing epp' do
     it 'epp can contain just text' do
       code = <<-CODE
       This is just text
       CODE
-      epp_tokens_scanned_from(code).should match_tokens2([:RENDER_STRING, "      This is just text\n"])
+      epp_tokens_scanned_from(code).should match_tokens2(:EPP_START, [:RENDER_STRING, "      This is just text\n"])
     end
 
     it 'epp can contain text with interpolated rendered expressions' do
       code = <<-CODE
       This is <%= $x %> just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:RENDER_EXPR, nil],
       [:VARIABLE, "x"],
       [:RENDER_STRING, " just text\n"]
       )
     end
 
     it 'epp can contain text with expressions that are not rendered' do
       code = <<-CODE
       This is <% $x=10 %> just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
       [:RENDER_STRING, " just text\n"]
       )
     end
 
     it 'epp can skip leading space in tail text' do
       code = <<-CODE
       This is <% $x=10 -%>
       just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
       [:RENDER_STRING, "just text\n"]
       )
     end
 
     it 'epp can skip comments' do
       code = <<-CODE
       This is <% $x=10 -%>
       <%# This is an epp comment -%>
       just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
       [:RENDER_STRING, "just text\n"]
       )
     end
 
     it 'epp can escape epp tags' do
       code = <<-CODE
       This is <% $x=10 -%>
       <%% this is escaped epp %%>
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
       [:RENDER_STRING, "<% this is escaped epp %>\n"]
       )
     end
   end
 end