diff --git a/lib/puppet/pops/model/factory.rb b/lib/puppet/pops/model/factory.rb
index d69e50e80..a01f86271 100644
--- a/lib/puppet/pops/model/factory.rb
+++ b/lib/puppet/pops/model/factory.rb
@@ -1,990 +1,1002 @@
 # 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_ReservedWord(o, name)
     o.word = name
     o
   end
 
   def build_KeyedEntry(o, k, v)
     o.key = to_ops(k)
     o.value = to_ops(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 = to_ops(b) 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 unfold(); f_build_unary(Model::UnfoldExpression, 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
 
   def self.record_position(o, start_locatable, end_locateable)
     new(o).record_position(start_locatable, end_locateable)
   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? || to.offset.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.unfold(o);                    new(o).unfold;                                          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
 
+
+  # Parameters
+
+  # Mark parameter as capturing the rest of arguments
+  def captures_rest()
+    current.captures_rest = true
+  end
+
+  # Set Expression that should evaluate to the parameter's type
+  def type_expr(o)
+    current.type_expr = to_ops(o)
+  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)
     see_scope = false
     params = parameters
     if parameters.nil?
       params = []
       see_scope = true
     end
     LAMBDA(params, new(Model::EppExpression, see_scope, body))
   end
 
   def self.RESERVED(name)
     new(Model::ReservedWord, name)
   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
 
   STATEMENT_CALLS = {
     'require' => true,
     'realize' => true,
     'include' => true,
     'contain' => true,
 
     'debug'   => true,
     'info'    => true,
     'notice'  => true,
     'warning' => true,
     'error'   => true,
 
     'fail'    => true,
     'import'  => true  # discontinued, but transform it to make it call error reporting function
   }
   # Returns true if the given name is a "statement keyword" (require, include, contain,
   # error, notice, info, debug
   #
   def name_is_statement(name)
     STATEMENT_CALLS[name]
   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) && STATEMENT_CALLS[name.value]
         the_call = Puppet::Pops::Model::Factory.CALL_NAMED(name, false, expr.is_a?(Array) ? expr : [expr])
         # last positioned is last arg if there are several
         record_position(the_call, name, expr.is_a?(Array) ? expr[-1]  : expr)
         memo[-1] = the_call
         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
 
   # Transforms a left expression followed by an untitled resource (in the form of attribute_operations)
   # @param left [Factory, Expression] the lhs followed what may be a hash
   def self.transform_resource_wo_title(left, attribute_ops)
     return nil unless attribute_ops.is_a? Array
     keyed_entries = attribute_ops.map do |ao|
       return nil if ao.operator == :'+>'
       KEY_ENTRY(ao.attribute_name, ao.value_expr)
     end
     result = block_or_expression(*transform_calls([left, HASH(keyed_entries)]))
     result
   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, see_scope, body)
     o.see_scope = see_scope
     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 e3de3ed31..da5fbdba7 100644
--- a/lib/puppet/pops/model/model.rb
+++ b/lib/puppet/pops/model/model.rb
@@ -1,614 +1,616 @@
 #
 # 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
 
   # Unfolds an array (a.k.a 'splat')
   class UnfoldExpression < 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
+    contains_one_uni 'type_expr', Expression, :lowerBound => 0
+    has_attr 'captures_rest', Boolean
   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
 
   # Represents a parsed reserved word
   class ReservedWord < LiteralValue
     has_attr 'word', 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 < Expression
     has_attr 'see_scope', Boolean
     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 3477cde1c..4aa8c03b9 100644
--- a/lib/puppet/pops/parser/egrammar.ra
+++ b/lib/puppet/pops/parser/egrammar.ra
@@ -1,783 +1,801 @@
 # vim: syntax=ruby
 
 # Parser using the Pops model, expression based
 
 class Puppet::Pops::Parser::Parser
 
 token STRING DQPRE DQMID DQPOST
 token WORD
 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 EPP_END EPP_END_TRIM
 token FUNCTION
 token PRIVATE ATTR TYPE
 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 SPLAT
   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 = 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] }
   |            TIMES        expression         =SPLAT  { result = val[1].unfold()         ; 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
   | reserved_word
 
 # Allways 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.
         # If the attribute operations does not include +>, then the found expression
         # is actually a LEFT followed by LITERAL_HASH
         #
         unless tmp = transform_resource_wo_title(val[0], val[2])
           error val[1], "Syntax error resource body without title or hash with +>"
         end
         tmp
       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_or_number   { result = Factory.literal(val[0][:value]); loc result, val[0] }
     | dotted_name DOT name_or_number { result = Factory.concat(val[0], '.', val[2][:value]); loc result, val[0], val[2] }
 
   name_or_number
     : NAME
     | NUMBER
 
   # Produces Expression, since hostname is an Expression
   nodeparent
     : nil
     | INHERITS hostname { result = val[1] }
 
 #---FUNCTION DEFINITION
 #
 #function_definition
   # For now the function word will just be reserved, in the future it will
   # produce a function definition
   # FUNCTION classname parameter_list LBRACE opt_statements RBRACE {
   #   result = add_definition(Factory.FUNCTION(val[1][:value], val[2], val[4]))
   #   loc result, val[0], val[5]
   # }
 
 #---NAMES AND PARAMETERS COMMON TO SEVERAL RULES
 #   Produces String
 #   TODO: The error that "class" is not a valid classname is bad - classname rule is also used for other things
 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
+  : untyped_parameter
+  | typed_parameter
+
+untyped_parameter
+  : regular_parameter
+  | splat_parameter
+
+regular_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] }
 
+splat_parameter
+  : TIMES regular_parameter { result = val[1]; val[1].captures_rest() }
+
+typed_parameter
+  : parameter_type untyped_parameter { val[1].type_expr(val[0]) ; result = val[1] }
+
+parameter_type
+  : type { result = val[0] }
+  | type LBRACK expressions RBRACK { result = val[0][*val[2]] ; loc result, val[0], val[3] }
+
 #--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] }
 
 #---RESERVED WORDS
 #
 reserved_word
   : FUNCTION  { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
   | PRIVATE   { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
   | TYPE      { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
   | ATTR      { result = Factory.RESERVED(val[0][:value]) ; 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] }
   | WORD    { 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] }
 
 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] }
 
 epp_expression
   : EPP_START epp_parameters_list statements { result = Factory.EPP(val[1], val[2]); loc result, val[0] }
 
 epp_parameters_list
   :                                  =LOW{ result = nil }
   | PIPE PIPE                        { result = [] }
   | PIPE parameters endcomma PIPE    { result = val[1] }
 
 epp_render_expression
   : RENDER_STRING                  { result = Factory.RENDER_STRING(val[0][:value]); loc result, val[0] }
   | RENDER_EXPR expression epp_end { result = Factory.RENDER_EXPR(val[1]); loc result, val[0], val[2] }
   | RENDER_EXPR LBRACE statements RBRACE epp_end { result = Factory.RENDER_EXPR(Factory.block_or_expression(*val[2])); loc result, val[0], val[4] }
 
 epp_end
   : EPP_END
   | EPP_END_TRIM
 
 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 0baa81078..509f9c852 100644
--- a/lib/puppet/pops/parser/eparser.rb
+++ b/lib/puppet/pops/parser/eparser.rb
@@ -1,2715 +1,2776 @@
 #
 # 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', 779)
+module_eval(<<'...end egrammar.ra/module_eval...', 'egrammar.ra', 797)
 
 # Make emacs happy
 # Local Variables:
 # mode: ruby
 # End:
 ...end egrammar.ra/module_eval...
 ##### State transition tables begin ###
 
 clist = [
-'63,66,275,-134,64,57,248,59,285,86,-225,-132,323,144,-234,255,308,260',
-'259,275,254,234,234,109,15,113,234,108,363,134,43,250,50,133,52,47,373',
-'51,76,72,369,45,75,48,49,-134,145,73,14,112,286,74,-225,-132,12,13,-234',
-'268,130,93,92,231,77,134,88,89,241,133,44,274,338,87,71,67,275,69,70',
-'68,270,271,53,54,56,55,63,66,134,58,64,57,133,59,405,94,134,253,306',
-'86,133,134,252,63,66,133,257,64,134,258,15,284,133,109,341,113,43,108',
-'50,282,52,47,134,51,76,72,133,45,75,48,49,343,81,73,14,345,358,74,357',
-'112,12,13,82,84,83,85,63,66,77,298,64,57,299,59,44,358,300,357,71,67',
-'284,69,70,251,350,351,53,54,56,55,15,352,234,58,245,355,43,122,50,359',
-'52,47,361,51,76,72,79,45,75,48,49,245,230,73,14,282,284,74,282,325,12',
-'13,370,306,294,216,293,217,77,291,219,295,289,288,44,290,292,306,71',
-'67,221,69,70,220,215,296,53,54,56,55,63,66,197,58,64,57,81,59,403,86',
-'164,218,297,380,307,161,382,159,284,282,135,385,122,109,15,113,123,108',
-'322,122,43,389,50,361,52,47,391,51,76,72,392,45,75,48,49,393,394,73',
-'14,112,395,74,119,397,12,13,398,399,326,93,92,81,77,78,88,89,406,407',
-'44,408,409,87,71,67,,69,70,,,,53,54,56,55,63,66,,58,64,57,,59,401,94',
-',,,86,,,,,,,,,,,15,,,109,,113,43,108,50,,52,47,,51,76,72,,45,75,48,49',
-',,73,14,,,74,,112,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,',
-',,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,',
-'74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55',
-'15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,',
-',63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43',
-',50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64',
+'63,66,282,292,64,57,333,59,-233,86,-134,-132,238,144,-242,238,318,282',
+'63,66,277,278,64,109,15,113,374,108,73,248,43,396,50,239,52,47,239,51',
+'76,72,252,45,75,48,49,293,145,73,14,112,-233,74,-134,-132,12,13,-242',
+'134,130,93,92,133,77,134,88,89,307,133,44,255,384,87,71,67,262,69,70',
+'68,351,261,53,54,56,55,63,66,134,58,64,57,133,59,417,94,257,260,238',
+'86,398,238,259,281,264,282,306,265,282,353,15,73,230,109,73,113,43,108',
+'50,239,52,47,239,51,76,72,355,45,75,48,49,134,305,73,14,133,231,74,313',
+'112,12,13,238,267,266,134,63,66,77,133,64,57,134,59,44,73,133,252,71',
+'67,134,69,70,239,133,291,53,54,56,55,15,258,369,58,368,360,43,275,50',
+'361,52,47,362,51,76,72,79,45,75,48,49,122,291,73,14,221,369,74,368,366',
+'12,13,336,370,301,216,300,217,77,298,219,302,296,295,44,297,299,372',
+'71,67,335,69,70,220,215,303,53,54,56,55,63,66,197,58,64,57,289,59,415',
+'86,291,218,304,82,84,83,85,289,380,381,332,313,81,109,15,113,164,108',
+'161,159,43,391,50,289,52,47,289,51,76,72,393,45,75,48,49,313,291,73',
+'14,112,135,74,81,348,12,13,122,123,317,93,92,314,77,122,88,89,401,372',
+'44,403,404,87,71,67,405,69,70,406,407,119,53,54,56,55,63,66,409,58,64',
+'57,410,59,413,94,411,238,81,86,78,418,419,420,421,,,,,,15,,,109,,113',
+'43,108,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,112,12,13,,,,',
+'63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,',
+'50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64',
 '57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51',
 '76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71',
 '67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,',
 ',,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,',
-'53,54,56,55,15,,,58,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,',
-',74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55',
-'15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,',
-',63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43',
-',50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64',
+'53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74',
+',,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15',
+',,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63',
+'66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50',
+',52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64',
 '57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51',
 '76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71',
 '67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,',
 ',,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,',
 '53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74',
 ',,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15',
-',,58,,,43,,50,,52,129,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63',
-'66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50',
-',52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57',
-',59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76',
-'72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67',
-',69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,',
-'73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53',
-'54,56,55,15,,,58,,,199,216,210,217,52,211,219,212,208,206,,201,214,',
-',,,73,14,220,215,213,,,12,13,,,,,,,77,,,,,218,200,,,,71,67,,69,70,,',
-',53,54,56,55,63,66,,58,64,57,148,59,,86,,,,,,,,,,,,,,109,15,113,,108',
-',,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,112,,74,,,12,13,,,,,63,66',
-'77,,64,57,150,59,44,,,87,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50',
-',52,115,,51,76,72,,45,75,,,,,73,14,,,74,,86,12,13,,,,,,,77,,,,,109,44',
-'113,,108,71,67,,69,70,,,,53,54,56,55,63,66,,58,64,57,,59,153,112,,,',
-',,,,,,,,,,,15,,,,,,43,87,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74',
-',,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15',
 ',,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63',
 '66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50',
 ',52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57',
-',59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76',
-'72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,163,44,,,,71,67',
+',59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,129,,51,76',
+'72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67',
 ',69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,',
 '73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53',
 '54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,',
 '12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,',
-',58,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,86,12,13,,',
-',,,,77,,,,,109,44,113,,108,71,67,,69,70,,,,53,54,56,55,63,66,,58,64',
-'57,,59,153,112,,,,86,,,,,,,,,,,15,,,109,,113,43,108,50,,52,47,,51,76',
-'72,,45,75,48,49,,,73,14,,,74,,112,12,13,,,,,63,66,77,,64,57,,59,44,',
-',,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,47,,51,76,72,,45',
-'75,48,49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69',
-'70,,,,53,54,56,55,15,,,58,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73',
-'14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54',
-'56,55,15,,,58,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,',
-'12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,',
-',58,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,,12,13,,,,',
-'63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,',
-'50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,,12,13,,,,,63,66,77,',
-'64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115',
+',58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,86,12,13,,,,,',
+',77,,,,,109,44,113,,108,71,67,,69,70,,,,53,54,56,55,63,66,,58,64,57',
+',59,311,112,,,,,,,,,,,,,,,15,,,,,,43,87,50,,52,47,,51,76,72,,45,75,48',
+'49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,148,59,44,,,,71,67,,69,70',
+',,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,',
+',74,,,12,13,,,,,63,66,77,,64,57,150,59,44,,,,71,67,,69,70,,,,53,54,56',
+'55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,86,12,13',
+',,,,,,77,,,,,109,44,113,,108,71,67,,69,70,,,,53,54,56,55,63,66,,58,64',
+'57,,59,153,112,,,,,,,,,,,,,,,15,,,,,,43,87,50,,52,115,,51,76,72,,45',
+'75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70',
+',,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,',
+',74,,,12,13,,,301,216,300,217,77,298,219,302,296,295,44,297,299,,71',
+'67,,69,70,220,215,303,53,54,56,55,63,66,,58,64,57,,59,320,86,,218,304',
+',,,,,,,,,,109,15,113,,108,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73',
+'14,112,,74,,,12,13,,90,91,93,92,,77,,88,89,,,44,,,87,71,67,,69,70,,',
+',53,54,56,55,63,66,,58,64,57,,59,153,94,,,,86,,,,,,,,,,,15,,,109,,113',
+'43,108,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,112,12,13,,,,',
+'63,66,77,,64,57,,163,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43',
+',50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,86,12,13,,,,,,,77,,,,,109',
+'44,113,,108,71,67,,69,70,,,,53,54,56,55,63,66,,58,64,57,,59,390,112',
+',,,,,,,,,,,,,,15,,,,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,',
+',74,,,12,13,,,,,63,66,77,,64,57,342,59,44,,,,71,67,,69,70,,,,53,54,56',
+'55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13',
+',,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,',
+'43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,,12,13,,,,,63,66',
+'77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52',
+'47,,51,76,72,,45,75,48,49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,',
+'59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,47,,51,76',
+'72,,45,75,48,49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71',
+'67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,47,,51,76,72,,45,75,48',
+'49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,',
+',,53,54,56,55,15,,,58,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14',
+',,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56',
+'55,15,,,58,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,,12',
+'13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58',
+',,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77',
+',64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115',
 ',51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,',
 ',,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45',
 '75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70',
 ',,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,',
 ',74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55',
 '15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,',
 ',63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43',
 ',50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64',
 '57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51',
 '76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71',
 '67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,',
 ',,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,',
 '53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74',
 ',,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15',
 ',,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63',
 '66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50',
 ',52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57',
 ',59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76',
 '72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67',
 ',69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,',
 '73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53',
 '54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,',
 '12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,',
 ',58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63',
 '66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50',
 ',52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57',
 ',59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76',
 '72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67',
 ',69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,',
 '73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53',
 '54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,',
 '12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,',
 ',58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63',
 '66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50',
 ',52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57',
 ',59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76',
 '72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67',
 ',69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,',
-'73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53',
-'54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,',
-'12,13,,,294,216,293,217,77,291,219,295,289,288,44,290,292,196,71,67',
-',69,70,220,215,296,53,54,56,55,63,66,,58,64,57,,59,379,,,218,297,,,',
-',,,,,,,,15,,,,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,',
-'12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,',
-',58,,,199,216,210,217,52,211,219,212,208,206,,201,214,,,,,73,14,220',
+'73,14,,,74,,,12,13,,,301,216,300,217,77,298,219,302,296,295,44,297,299',
+'196,71,67,,69,70,220,215,303,53,54,56,55,63,66,,58,64,57,,59,375,,,218',
+'304,,,,,,,,,,,,15,,,,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74',
+',,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15',
+',,58,,,199,216,210,217,52,211,219,212,208,206,,201,214,,,,,73,14,220',
 '215,213,,,12,13,,,,,,,77,,,,,218,200,,,,71,67,,69,70,,,,53,54,56,55',
-'63,66,,58,64,57,,59,294,216,293,217,,291,219,295,289,288,,290,292,,',
-',15,,,220,215,296,43,,50,,52,47,,51,76,72,,45,75,48,49,218,297,73,14',
+'63,66,,58,64,57,,59,,,,,,,,,,,,,,,,,15,,,,,,43,,50,,52,115,,51,76,72',
+',45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69',
+'70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14',
 ',,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56',
 '55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13',
 ',,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,',
 '43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77',
 ',64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115',
-',51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,,,77,,,,,,44,,,,71,67,,69',
-'70,,,,53,54,56,55,63,66,,58,64,57,,59,312,86,,,,,,,,,,,,,,109,15,113',
-',108,,,43,,50,,52,47,,51,76,72,,45,75,48,49,,,73,14,112,,74,,,12,13',
-',90,91,93,92,,77,,88,89,,,44,,,87,71,67,,69,70,,,,53,54,56,55,63,66',
-',58,64,57,,59,310,94,,,,,,,,,,,,,,,15,,,,,,43,,50,,52,47,,51,76,72,',
-'45,75,48,49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,331,59,44,,,,71',
-'67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,',
-',,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,',
-'53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74',
-',,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15',
-'228,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,',
-',,,77,,,,,,44,,,,71,67,,69,70,,,,53,54,56,55,63,66,,58,64,57,,59,364',
-'86,,,,,,,,,,,,,,109,15,113,,108,,,43,,50,,52,115,,51,76,72,,45,75,,',
-',,73,14,112,,74,,,12,13,,90,91,93,92,,77,,88,89,,,44,,,87,71,67,,69',
-'70,,,,53,54,56,55,63,66,,58,64,57,,59,304,94,,,,,,,,,,,,,,,15,,,,,,43',
-',50,,52,47,,51,76,72,,45,75,48,49,,,73,14,,,74,,,12,13,,,,,63,66,77',
-',64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,236,,58,,,43,,50,,52',
+',51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,',
+',,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45',
+'75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70',
+',,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,',
+',74,,,12,13,,,,,,,77,,,,,,44,,,,71,67,,69,70,,,,53,54,56,55,63,66,,58',
+'64,57,,59,322,,,,,,,,,,,,,,,,15,,,,,,43,,50,,52,47,,51,76,72,,45,75',
+'48,49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70',
+',,,53,54,56,55,15,228,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14',
+',,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56',
+'55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13',
+',,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,',
+'43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77',
+',64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,243,,58,,,43,,50,,52',
 '115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59',
 '44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,47,,51,76,72',
 ',45,75,48,49,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67',
 ',69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,',
 '73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53',
-'54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,',
-'12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,',
-',58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63',
-'66,77,,64,57,332,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,',
-'50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64',
-'57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51',
-'76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71',
-'67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,',
-',,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,',
-'53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74',
-',,12,13,,,,,,,77,,,,,,44,,,,71,67,,69,70,,,,53,54,56,55,63,66,,58,64',
-'57,,59,334,,,,,,,,,,,,,,,,15,,,,,,43,,50,,52,115,,51,76,72,,45,75,,',
-',,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53',
-'54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,',
-'12,13,,,,,,,77,,,,,,44,,,,71,67,,69,70,,,86,53,54,56,55,,,,58,105,106',
-'107,102,97,109,,113,,108,,,98,100,99,101,,,,,,,,,,,,,,,,112,,,,104,103',
-',,90,91,93,92,95,96,,88,89,86,,240,,,87,,,,105,106,107,102,97,109,,113',
-',108,,,98,100,99,101,,,94,,,,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95',
-'96,86,88,89,,,,,,87,105,106,107,102,97,109,,113,,108,,,98,100,99,101',
-',,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,256,',
+'54,56,55,15,,,58,,,199,216,210,217,52,211,219,212,208,206,,201,214,',
+',,,73,14,220,215,213,,,12,13,,,,,,,77,,,,,218,200,,,,71,67,,69,70,,',
+',53,54,56,55,63,66,,58,64,57,,59,,,,,,,,,,,,,,,,,15,,,,,,43,,50,,52',
+'115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59',
+'44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72',
+',45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69',
+'70,,,,53,54,56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14',
+',,74,,,12,13,,,,,63,66,77,,64,57,341,59,44,,,,71,67,,69,70,,,,53,54',
+'56,55,15,,,58,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12',
+'13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58',
+',,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,,,77,,',
+',,,44,,,,71,67,,69,70,,,,53,54,56,55,63,66,,58,64,57,,59,344,,,,,,,',
+',,,,,,,,15,,,,,,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12',
+'13,,,,,63,66,77,,64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58',
+',,43,,50,,52,115,,51,76,72,,45,75,,,,,73,14,,,74,,,12,13,,,,,63,66,77',
+',64,57,,59,44,,,,71,67,,69,70,,,,53,54,56,55,15,,,58,,,43,,50,,52,47',
+',51,76,72,,45,75,48,49,,,73,14,,,74,,,12,13,,,,,,,77,,,,,,44,,,,71,67',
+',69,70,,,86,53,54,56,55,,,,58,105,106,107,102,97,109,,113,,108,,,98',
+'100,99,101,,,,,,,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,,88,89',
+',86,,110,,87,263,,,,105,106,107,102,97,109,,113,,108,,,98,100,99,101',
+',94,,,,,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,263,',
 ',87,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,,,,,94,,,,,,,',
-',,112,,,,104,103,,,90,91,93,92,95,96,,88,89,86,,239,,,87,,,,105,106',
+',,112,,,,104,103,,,90,91,93,92,95,96,,88,89,86,,247,,,87,,,,105,106',
 '107,102,97,109,,113,,108,,,98,100,99,101,,,94,,,,,,,,,,,,,112,,,,104',
 '103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106,107,102,97,109,,113',
 ',108,,,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95',
-'96,,88,89,86,,238,,,87,,,,105,106,107,102,97,109,,113,,108,,,98,100',
-'99,101,,,94,,,,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,,88,89,,86',
-',110,,87,256,,,,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,94',
-',,,,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,,88,89,86,,237,,,87',
-',,,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,,94,,,,,,,,,,,',
-',112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106,107,102',
-'97,109,,113,,108,,226,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103',
+'96,,88,89,86,,246,,,87,,,,105,106,107,102,97,109,,113,,108,,,98,100',
+'99,101,,,94,,,,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,,88,89,86',
+',245,,,87,,,,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,,94,',
+',,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,,88,89,86,,244,,,87,,',
+',105,106,107,102,97,109,,113,,108,,,98,100,99,101,,,94,,,,,,,,,,,,,112',
+',,,104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106,107,102,97,109',
+',113,,108,,226,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91',
+'93,92,95,96,86,88,89,,,,,,87,105,106,107,102,97,109,,113,,108,,,98,100',
+'99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89',
+',,,,,87,105,106,107,102,97,109,,113,,108,277,278,98,100,99,101,,,,,',
+'94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105',
+'106,107,102,97,109,,113,,108,,,98,100,99,101,,,,,,94,,,,,,,,,,112,,',
+',104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106,107,102,97,109',
+',113,,108,,,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93',
+'92,95,96,86,88,89,,,,,,87,105,106,107,102,97,109,,113,,108,,,98,100',
+'99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89',
+',,,,,87,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,,,,,94,,,',
+',,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106,107',
+'102,97,109,,113,,108,,,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103',
 ',,90,91,93,92,95,96,86,88,89,,,,,,87,105,106,107,102,97,109,,113,,108',
 ',,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96',
-'86,88,89,,,,,,87,105,106,107,102,97,109,,113,,108,270,271,98,100,99',
-'101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,',
-',,87,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,,,,,94,,,,,,',
-',,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106,107,102',
-'97,109,,113,,108,,,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90',
-'91,93,92,95,96,86,88,89,,,,,,87,105,106,107,102,97,109,,113,,108,,,98',
-'100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88',
-'89,,,,,,87,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,,,,,94',
-',,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106',
-'107,102,97,109,,113,,108,,,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104',
-'103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106,107,102,97,109,280',
-'113,,108,,,98,100,99,101,,,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93',
-'92,95,96,,88,89,86,,110,,,87,,,,105,106,107,102,97,109,,113,,108,,,98',
-'100,99,101,,,94,,,,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88',
-'89,,,276,,,87,105,106,107,102,97,109,,113,86,108,,,98,100,99,101,,,',
-',,94,109,,113,,108,,,,,112,,,,104,103,,,90,91,93,92,95,96,,88,89,112',
-',,86,,87,,,90,91,93,92,95,96,,88,89,109,,113,86,108,87,,,,,94,,,,,,97',
-'109,,113,,108,,,98,,112,94,,,,,,,90,91,93,92,95,96,,88,89,112,,,,,87',
-',86,90,91,93,92,95,96,,88,89,,,,97,109,87,113,86,108,,94,98,,,,,,,,',
-'97,109,,113,,108,,94,98,,112,63,66,,,64,,,90,91,93,92,95,96,,88,89,112',
-',,,,87,,,90,91,93,92,95,96,,88,89,,,86,,,87,144,,,141,94,105,106,107',
-'102,97,109,,113,,108,,,98,100,99,101,94,,77,,,,,,,,,,145,67,,112,,,',
-'104,103,,86,90,91,93,92,95,96,,88,89,,,102,97,109,87,113,,108,,86,98',
-'100,99,101,,,,,,,,102,97,109,,113,94,108,,112,98,100,99,101,,,,90,91',
-'93,92,95,96,,88,89,,,,112,,87,,,103,,,90,91,93,92,95,96,,88,89,86,,',
-',,87,,94,,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,,94,,,,',
-',,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105,106',
-'107,102,97,109,,113,,108,,86,98,100,99,101,63,66,,,64,94,,,97,109,,113',
-',108,,112,98,,,104,103,,,90,91,93,92,95,96,,88,89,63,66,,112,64,87,',
-'144,,,141,90,91,93,92,95,96,,88,89,86,,63,66,,87,64,94,,,77,,,,109,',
-'113,86,108,144,145,67,141,,,,,94,,86,,109,,113,,108,,,,,112,144,77,109',
-'141,113,,108,,,,,145,67,,88,89,112,,,,,87,,77,,,,,112,,,88,89,145,67',
-',,,87,,,,,88,89,,,,,,87' ]
-        racc_action_table = arr = ::Array.new(6903, nil)
+'86,88,89,,,,,,87,105,106,107,102,97,109,287,113,,108,,,98,100,99,101',
+',,,,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,,88,89,86,,110,',
+',87,,,,105,106,107,102,97,109,,113,86,108,,,98,100,99,101,,,94,,,,109',
+',113,,108,,,,,112,,,,104,103,,,90,91,93,92,95,96,,88,89,112,,,86,,87',
+',,90,91,93,92,,,,88,89,109,,113,86,108,87,,,,,94,,,,,,,109,,113,,108',
+',,,,112,94,,,,,,,90,91,93,92,95,96,,88,89,112,,,,,87,,86,90,91,93,92',
+'95,96,,88,89,,,,97,109,87,113,86,108,,94,98,,,,,,,,,97,109,,113,,108',
+',94,98,,112,,,,,,,,90,91,93,92,95,96,,88,89,112,,,,,87,,86,90,91,93',
+'92,95,96,,88,89,,,,97,109,87,113,86,108,,94,98,,,,,,,,,97,109,,113,',
+'108,,94,98,,112,,,,,,,,90,91,93,92,95,96,,88,89,112,,,,,87,,86,90,91',
+'93,92,95,96,,88,89,,,102,97,109,87,113,,108,,94,98,100,99,101,,,,,,',
+',,,,,,94,,,112,,,,,86,,,90,91,93,92,95,96,,88,89,102,97,109,,113,87',
+'108,,86,98,100,99,101,,,,,105,106,107,102,97,109,,113,,108,94,112,98',
+'100,99,101,103,,,90,91,93,92,95,96,,88,89,,,,112,,87,,104,103,,,90,91',
+'93,92,95,96,,88,89,86,,,,,87,,94,,105,106,107,102,97,109,,113,,108,',
+',98,100,99,101,,,94,,,,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86',
+'88,89,,,283,,,87,105,106,107,102,97,109,,113,,108,,,98,100,99,101,,',
+',,,94,,,,,,,,,,112,,,,104,103,,,90,91,93,92,95,96,86,88,89,,,,,,87,105',
+'106,107,102,97,109,,113,,108,,,98,100,99,101,63,66,63,66,64,94,64,63',
+'66,63,66,64,,64,,112,,,,104,103,,,90,91,93,92,95,96,,88,89,,,,,86,87',
+',144,,144,141,,141,,144,86,144,141,109,141,113,,108,,,,,94,,109,77,113',
+'77,108,,,,77,86,77,145,67,145,67,112,,,145,67,145,67,,109,,113,112,108',
+',,88,89,,,,,,87,,,,88,89,,,,,,87,112,,,,,,,,,,,,,,,88,89,,,,,,87' ]
+        racc_action_table = arr = ::Array.new(7002, 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,235,208,0,0,137,0,209,175,214,206,245,251,213,149,235,157,157,313',
-'149,245,161,175,0,175,122,175,313,322,0,137,0,322,0,0,322,0,0,0,319',
-'0,0,0,0,208,251,0,0,175,209,0,214,206,0,0,213,161,47,175,175,122,0,211',
-'175,175,129,211,0,171,273,175,0,0,171,0,0,0,338,338,0,0,0,0,392,392',
-'47,0,392,392,47,392,392,175,129,147,267,117,129,210,147,159,159,210',
-'152,159,50,152,392,203,50,117,277,117,392,117,392,202,392,392,115,392',
-'392,392,115,392,392,392,392,281,165,392,392,283,310,392,310,117,392',
-'392,8,8,8,8,5,5,392,223,5,5,225,5,392,355,227,355,392,392,287,392,392',
-'139,301,303,392,392,392,392,5,305,306,392,136,309,5,228,5,311,5,5,312',
-'5,5,5,5,5,5,5,5,131,121,5,5,316,317,5,318,246,5,5,320,232,279,279,279',
-'279,5,279,279,279,279,279,5,279,279,324,5,5,111,5,5,279,279,279,5,5',
-'5,5,391,391,109,5,391,391,80,391,391,176,78,279,279,337,234,68,340,67',
-'342,242,48,349,350,176,391,176,42,176,243,41,391,358,391,359,391,391',
-'361,391,391,391,362,391,391,391,391,366,367,391,391,176,368,391,40,374',
-'391,391,375,378,247,176,176,6,391,1,176,176,396,400,391,402,404,176',
-'391,391,,391,391,,,,391,391,391,391,389,389,,391,389,389,,389,389,176',
-',,,172,,,,,,,,,,,389,,,172,,172,389,172,389,,389,389,,389,389,389,,389',
-'389,389,389,,,389,389,,,389,,172,389,389,,,,,196,196,389,,196,196,,196',
-'389,,,,389,389,,389,389,,,,389,389,389,389,196,,,389,,,196,,196,,196',
-'196,,196,196,196,,196,196,,,,,196,196,,,196,,,196,196,,,,,12,12,196',
-',12,12,,12,196,,,,196,196,,196,196,,,,196,196,196,196,12,,,196,,,12',
-',12,,12,12,,12,12,12,,12,12,,,,,12,12,,,12,,,12,12,,,,,13,13,12,,13',
-'13,,13,12,,,,12,12,,12,12,,,,12,12,12,12,13,,,12,,,13,,13,,13,13,,13',
-'13,13,,13,13,,,,,13,13,,,13,,,13,13,,,,,14,14,13,,14,14,,14,13,,,,13',
-'13,,13,13,,,,13,13,13,13,14,,,13,,,14,,14,,14,14,,14,14,14,,14,14,,',
-',,14,14,,,14,,,14,14,,,,,15,15,14,,15,15,,15,14,,,,14,14,,14,14,,,,14',
-'14,14,14,15,,,14,,,15,,15,,15,15,,15,15,15,,15,15,,,,,15,15,,,15,,,15',
-'15,,,,,370,370,15,,370,370,,370,15,,,,15,15,,15,15,,,,15,15,15,15,370',
-',,15,,,370,,370,,370,370,,370,370,370,,370,370,370,370,,,370,370,,,370',
-',,370,370,,,,,357,357,370,,357,357,,357,370,,,,370,370,,370,370,,,,370',
-'370,370,370,357,,,370,,,357,,357,,357,357,,357,357,357,,357,357,,,,',
-'357,357,,,357,,,357,357,,,,,199,199,357,,199,199,,199,357,,,,357,357',
-',357,357,,,,357,357,357,357,199,,,357,,,199,,199,,199,199,,199,199,199',
-',199,199,,,,,199,199,,,199,,,199,199,,,,,43,43,199,,43,43,,43,199,,',
-',199,199,,199,199,,,,199,199,199,199,43,,,199,,,43,,43,,43,43,,43,43',
-'43,,43,43,,,,,43,43,,,43,,,43,43,,,,,44,44,43,,44,44,,44,43,,,,43,43',
-',43,43,,,,43,43,43,43,44,,,43,,,44,,44,,44,44,,44,44,44,,44,44,,,,,44',
-'44,,,44,,,44,44,,,,,45,45,44,,45,45,,45,44,,,,44,44,,44,44,,,,44,44',
-'44,44,45,,,44,,,45,,45,,45,45,,45,45,45,,45,45,,,,,45,45,,,45,,,45,45',
-',,,,46,46,45,,46,46,,46,45,,,,45,45,,45,45,,,,45,45,45,45,46,,,45,,',
-'46,,46,,46,46,,46,46,46,,46,46,,,,,46,46,,,46,,,46,46,,,,,241,241,46',
-',241,241,,241,46,,,,46,46,,46,46,,,,46,46,46,46,241,,,46,,,241,,241',
-',241,241,,241,241,241,,241,241,,,,,241,241,,,241,,,241,241,,,,,200,200',
-'241,,200,200,,200,241,,,,241,241,,241,241,,,,241,241,241,241,200,,,241',
-',,200,,200,,200,200,,200,200,200,,200,200,,,,,200,200,,,200,,,200,200',
-',,,,201,201,200,,201,201,,201,200,,,,200,200,,200,200,,,,200,200,200',
-'200,201,,,200,,,201,,201,,201,201,,201,201,201,,201,201,,,,,201,201',
-',,201,,,201,201,,,,,240,240,201,,240,240,,240,201,,,,201,201,,201,201',
-',,,201,201,201,201,240,,,201,,,240,240,240,240,240,240,240,240,240,240',
-',240,240,,,,,240,240,240,240,240,,,240,240,,,,,,,240,,,,,240,240,,,',
-'240,240,,240,240,,,,240,240,240,240,57,57,,240,57,57,57,57,,174,,,,',
-',,,,,,,,,174,57,174,,174,,,57,,57,,57,57,,57,57,57,,57,57,,,,,57,57',
-'174,,57,,,57,57,,,,,58,58,57,,58,58,58,58,57,,,174,57,57,,57,57,,,,57',
-'57,57,57,58,,,57,,,58,,58,,58,58,,58,58,58,,58,58,,,,,58,58,,,58,,173',
-'58,58,,,,,,,58,,,,,173,58,173,,173,58,58,,58,58,,,,58,58,58,58,59,59',
-',58,59,59,,59,59,173,,,,,,,,,,,,,,,59,,,,,,59,173,59,,59,59,,59,59,59',
-',59,59,,,,,59,59,,,59,,,59,59,,,,,65,65,59,,65,65,,65,59,,,,59,59,,59',
-'59,,,,59,59,59,59,65,,,59,,,65,,65,,65,65,,65,65,65,,65,65,,,,,65,65',
-',,65,,,65,65,,,,,341,341,65,,341,341,,341,65,,,,65,65,,65,65,,,,65,65',
-'65,65,341,,,65,,,341,,341,,341,341,,341,341,341,,341,341,,,,,341,341',
-',,341,,,341,341,,,,,276,276,341,,276,276,,276,341,,,,341,341,,341,341',
-',,,341,341,341,341,276,,,341,,,276,,276,,276,276,,276,276,276,,276,276',
-',,,,276,276,,,276,,,276,276,,,,,70,70,276,,70,70,,70,276,,,,276,276',
-',276,276,,,,276,276,276,276,70,,,276,,,70,,70,,70,70,,70,70,70,,70,70',
-',,,,70,70,,,70,,,70,70,,,,,282,282,70,,282,282,,282,70,,,,70,70,,70',
-'70,,,,70,70,70,70,282,,,70,,,282,,282,,282,282,,282,282,282,,282,282',
-',,,,282,282,,,282,,,282,282,,,,,79,79,282,,79,79,,79,282,,,,282,282',
-',282,282,,,,282,282,282,282,79,,,282,,,79,,79,,79,79,,79,79,79,,79,79',
-'79,79,,,79,79,,,79,,116,79,79,,,,,,,79,,,,,116,79,116,,116,79,79,,79',
-'79,,,,79,79,79,79,163,163,,79,163,163,,163,163,116,,,,114,,,,,,,,,,',
-'163,,,114,,114,163,114,163,,163,163,,163,163,163,,163,163,163,163,,',
-'163,163,,,163,,114,163,163,,,,,81,81,163,,81,81,,81,163,,,,163,163,',
-'163,163,,,,163,163,163,163,81,,,163,,,81,,81,,81,81,,81,81,81,,81,81',
-'81,81,,,81,81,,,81,,,81,81,,,,,82,82,81,,82,82,,82,81,,,,81,81,,81,81',
-',,,81,81,81,81,82,,,81,,,82,,82,,82,82,,82,82,82,,82,82,82,82,,,82,82',
-',,82,,,82,82,,,,,83,83,82,,83,83,,83,82,,,,82,82,,82,82,,,,82,82,82',
-'82,83,,,82,,,83,,83,,83,83,,83,83,83,,83,83,83,83,,,83,83,,,83,,,83',
-'83,,,,,84,84,83,,84,84,,84,83,,,,83,83,,83,83,,,,83,83,83,83,84,,,83',
-',,84,,84,,84,84,,84,84,84,,84,84,84,84,,,84,84,,,84,,,84,84,,,,,85,85',
-'84,,85,85,,85,84,,,,84,84,,84,84,,,,84,84,84,84,85,,,84,,,85,,85,,85',
-'85,,85,85,85,,85,85,85,85,,,85,85,,,85,,,85,85,,,,,86,86,85,,86,86,',
-'86,85,,,,85,85,,85,85,,,,85,85,85,85,86,,,85,,,86,,86,,86,86,,86,86',
-'86,,86,86,,,,,86,86,,,86,,,86,86,,,,,87,87,86,,87,87,,87,86,,,,86,86',
-',86,86,,,,86,86,86,86,87,,,86,,,87,,87,,87,87,,87,87,87,,87,87,,,,,87',
-'87,,,87,,,87,87,,,,,88,88,87,,88,88,,88,87,,,,87,87,,87,87,,,,87,87',
-'87,87,88,,,87,,,88,,88,,88,88,,88,88,88,,88,88,,,,,88,88,,,88,,,88,88',
-',,,,89,89,88,,89,89,,89,88,,,,88,88,,88,88,,,,88,88,88,88,89,,,88,,',
-'89,,89,,89,89,,89,89,89,,89,89,,,,,89,89,,,89,,,89,89,,,,,90,90,89,',
-'90,90,,90,89,,,,89,89,,89,89,,,,89,89,89,89,90,,,89,,,90,,90,,90,90',
-',90,90,90,,90,90,,,,,90,90,,,90,,,90,90,,,,,91,91,90,,91,91,,91,90,',
-',,90,90,,90,90,,,,90,90,90,90,91,,,90,,,91,,91,,91,91,,91,91,91,,91',
-'91,,,,,91,91,,,91,,,91,91,,,,,92,92,91,,92,92,,92,91,,,,91,91,,91,91',
-',,,91,91,91,91,92,,,91,,,92,,92,,92,92,,92,92,92,,92,92,,,,,92,92,,',
-'92,,,92,92,,,,,93,93,92,,93,93,,93,92,,,,92,92,,92,92,,,,92,92,92,92',
-'93,,,92,,,93,,93,,93,93,,93,93,93,,93,93,,,,,93,93,,,93,,,93,93,,,,',
-'94,94,93,,94,94,,94,93,,,,93,93,,93,93,,,,93,93,93,93,94,,,93,,,94,',
-'94,,94,94,,94,94,94,,94,94,,,,,94,94,,,94,,,94,94,,,,,95,95,94,,95,95',
-',95,94,,,,94,94,,94,94,,,,94,94,94,94,95,,,94,,,95,,95,,95,95,,95,95',
-'95,,95,95,,,,,95,95,,,95,,,95,95,,,,,96,96,95,,96,96,,96,95,,,,95,95',
-',95,95,,,,95,95,95,95,96,,,95,,,96,,96,,96,96,,96,96,96,,96,96,,,,,96',
-'96,,,96,,,96,96,,,,,97,97,96,,97,97,,97,96,,,,96,96,,96,96,,,,96,96',
-'96,96,97,,,96,,,97,,97,,97,97,,97,97,97,,97,97,,,,,97,97,,,97,,,97,97',
-',,,,98,98,97,,98,98,,98,97,,,,97,97,,97,97,,,,97,97,97,97,98,,,97,,',
-'98,,98,,98,98,,98,98,98,,98,98,,,,,98,98,,,98,,,98,98,,,,,99,99,98,',
-'99,99,,99,98,,,,98,98,,98,98,,,,98,98,98,98,99,,,98,,,99,,99,,99,99',
-',99,99,99,,99,99,,,,,99,99,,,99,,,99,99,,,,,100,100,99,,100,100,,100',
-'99,,,,99,99,,99,99,,,,99,99,99,99,100,,,99,,,100,,100,,100,100,,100',
-'100,100,,100,100,,,,,100,100,,,100,,,100,100,,,,,101,101,100,,101,101',
-',101,100,,,,100,100,,100,100,,,,100,100,100,100,101,,,100,,,101,,101',
-',101,101,,101,101,101,,101,101,,,,,101,101,,,101,,,101,101,,,,,102,102',
-'101,,102,102,,102,101,,,,101,101,,101,101,,,,101,101,101,101,102,,,101',
-',,102,,102,,102,102,,102,102,102,,102,102,,,,,102,102,,,102,,,102,102',
-',,,,103,103,102,,103,103,,103,102,,,,102,102,,102,102,,,,102,102,102',
-'102,103,,,102,,,103,,103,,103,103,,103,103,103,,103,103,,,,,103,103',
-',,103,,,103,103,,,,,104,104,103,,104,104,,104,103,,,,103,103,,103,103',
-',,,103,103,103,103,104,,,103,,,104,,104,,104,104,,104,104,104,,104,104',
-',,,,104,104,,,104,,,104,104,,,,,105,105,104,,105,105,,105,104,,,,104',
-'104,,104,104,,,,104,104,104,104,105,,,104,,,105,,105,,105,105,,105,105',
-'105,,105,105,,,,,105,105,,,105,,,105,105,,,,,106,106,105,,106,106,,106',
-'105,,,,105,105,,105,105,,,,105,105,105,105,106,,,105,,,106,,106,,106',
-'106,,106,106,106,,106,106,,,,,106,106,,,106,,,106,106,,,,,107,107,106',
-',107,107,,107,106,,,,106,106,,106,106,,,,106,106,106,106,107,,,106,',
-',107,,107,,107,107,,107,107,107,,107,107,,,,,107,107,,,107,,,107,107',
-',,,,108,108,107,,108,108,,108,107,,,,107,107,,107,107,,,,107,107,107',
-'107,108,,,107,,,108,,108,,108,108,,108,108,108,,108,108,,,,,108,108',
-',,108,,,108,108,,,284,284,284,284,108,284,284,284,284,284,108,284,284',
-'108,108,108,,108,108,284,284,284,108,108,108,108,326,326,,108,326,326',
-',326,326,,,284,284,,,,,,,,,,,,326,,,,,,326,,326,,326,326,,326,326,326',
-',326,326,326,326,,,326,326,,,326,,,326,326,,,,,110,110,326,,110,110',
-',110,326,,,,326,326,,326,326,,,,326,326,326,326,110,,,326,,,110,110',
-'110,110,110,110,110,110,110,110,,110,110,,,,,110,110,110,110,110,,,110',
-'110,,,,,,,110,,,,,110,110,,,,110,110,,110,110,,,,110,110,110,110,325',
-'325,,110,325,325,,325,221,221,221,221,,221,221,221,221,221,,221,221',
-',,,325,,,221,221,221,325,,325,,325,325,,325,325,325,,325,325,325,325',
-'221,221,325,325,,,325,,,325,325,,,,,112,112,325,,112,112,,112,325,,',
-',325,325,,325,325,,,,325,325,325,325,112,,,325,,,112,,112,,112,112,',
-'112,112,112,,112,112,,,,,112,112,,,112,,,112,112,,,,,113,113,112,,113',
-'113,,113,112,,,,112,112,,112,112,,,,112,112,112,112,113,,,112,,,113',
-',113,,113,113,,113,113,113,,113,113,,,,,113,113,,,113,,,113,113,,,,',
-'239,239,113,,239,239,,239,113,,,,113,113,,113,113,,,,113,113,113,113',
-'239,,,113,,,239,,239,,239,239,,239,239,239,,239,239,,,,,239,239,,,239',
-',,239,239,,,,,,,239,,,,,,239,,,,239,239,,239,239,,,,239,239,239,239',
-'238,238,,239,238,238,,238,238,180,,,,,,,,,,,,,,180,238,180,,180,,,238',
-',238,,238,238,,238,238,238,,238,238,238,238,,,238,238,180,,238,,,238',
-'238,,180,180,180,180,,238,,180,180,,,238,,,180,238,238,,238,238,,,,238',
-'238,238,238,237,237,,238,237,237,,237,237,180,,,,,,,,,,,,,,,237,,,,',
-',237,,237,,237,237,,237,237,237,,237,237,237,237,,,237,237,,,237,,,237',
-'237,,,,,252,252,237,,252,252,252,252,237,,,,237,237,,237,237,,,,237',
-'237,237,237,252,,,237,,,252,,252,,252,252,,252,252,252,,252,252,,,,',
-'252,252,,,252,,,252,252,,,,,275,275,252,,275,275,,275,252,,,,252,252',
-',252,252,,,,252,252,252,252,275,,,252,,,275,,275,,275,275,,275,275,275',
-',275,275,,,,,275,275,,,275,,,275,275,,,,,119,119,275,,119,119,,119,275',
-',,,275,275,,275,275,,,,275,275,275,275,119,119,,275,,,119,,119,,119',
-'119,,119,119,119,,119,119,,,,,119,119,,,119,,,119,119,,,,,,,119,,,,',
-',119,,,,119,119,,119,119,,,,119,119,119,119,314,314,,119,314,314,,314',
-'314,181,,,,,,,,,,,,,,181,314,181,,181,,,314,,314,,314,314,,314,314,314',
-',314,314,,,,,314,314,181,,314,,,314,314,,181,181,181,181,,314,,181,181',
-',,314,,,181,314,314,,314,314,,,,314,314,314,314,230,230,,314,230,230',
-',230,230,181,,,,,,,,,,,,,,,230,,,,,,230,,230,,230,230,,230,230,230,',
-'230,230,230,230,,,230,230,,,230,,,230,230,,,,,123,123,230,,123,123,',
-'123,230,,,,230,230,,230,230,,,,230,230,230,230,123,123,,230,,,123,,123',
-',123,123,,123,123,123,,123,123,,,,,123,123,,,123,,,123,123,,,,,160,160',
+'0,0,242,209,0,0,252,0,214,175,208,206,240,258,213,252,242,323,159,159',
+'348,348,159,175,0,175,323,175,252,129,0,359,0,240,0,0,252,0,0,0,131',
+'0,0,0,0,209,258,0,0,175,214,0,208,206,0,0,213,129,47,175,175,129,0,332',
+'175,175,227,332,0,137,332,175,0,0,149,0,0,0,284,149,0,0,0,0,404,404',
+'47,0,404,404,47,404,404,175,137,147,313,116,365,122,147,171,152,365',
+'225,152,171,288,404,313,121,116,122,116,404,116,404,313,404,404,122',
+'404,404,404,290,404,404,404,404,50,223,404,404,50,122,404,274,116,404',
+'404,161,157,157,210,5,5,404,210,5,5,115,5,404,161,115,136,404,404,211',
+'404,404,161,211,294,404,404,404,404,5,139,366,404,366,308,5,161,5,310',
+'5,5,312,5,5,5,5,5,5,5,5,228,203,5,5,111,320,5,320,319,5,5,254,321,286',
+'286,286,286,5,286,286,286,286,286,5,286,286,322,5,5,253,5,5,286,286',
+'286,5,5,5,5,403,403,109,5,403,403,326,403,403,176,327,286,286,8,8,8',
+'8,328,329,330,250,334,80,176,403,176,78,176,68,67,403,347,403,249,403',
+'403,202,403,403,403,350,403,403,403,403,232,352,403,403,176,48,403,165',
+'280,403,403,360,42,241,176,176,238,403,41,176,176,369,370,403,372,373',
+'176,403,403,377,403,403,378,379,40,403,403,403,403,401,401,385,403,401',
+'401,386,401,401,176,389,239,6,114,1,408,412,414,416,,,,,,401,,,114,',
+'114,401,114,401,,401,401,,401,401,401,,401,401,401,401,,,401,401,,,401',
+',114,401,401,,,,,196,196,401,,196,196,,196,401,,,,401,401,,401,401,',
+',,401,401,401,401,196,,,401,,,196,,196,,196,196,,196,196,196,,196,196',
+',,,,196,196,,,196,,,196,196,,,,,12,12,196,,12,12,,12,196,,,,196,196',
+',196,196,,,,196,196,196,196,12,,,196,,,12,,12,,12,12,,12,12,12,,12,12',
+',,,,12,12,,,12,,,12,12,,,,,13,13,12,,13,13,,13,12,,,,12,12,,12,12,,',
+',12,12,12,12,13,,,12,,,13,,13,,13,13,,13,13,13,,13,13,,,,,13,13,,,13',
+',,13,13,,,,,14,14,13,,14,14,,14,13,,,,13,13,,13,13,,,,13,13,13,13,14',
+',,13,,,14,,14,,14,14,,14,14,14,,14,14,,,,,14,14,,,14,,,14,14,,,,,15',
+'15,14,,15,15,,15,14,,,,14,14,,14,14,,,,14,14,14,14,15,,,14,,,15,,15',
+',15,15,,15,15,15,,15,15,,,,,15,15,,,15,,,15,15,,,,,381,381,15,,381,381',
+',381,15,,,,15,15,,15,15,,,,15,15,15,15,381,,,15,,,381,,381,,381,381',
+',381,381,381,,381,381,381,381,,,381,381,,,381,,,381,381,,,,,368,368',
+'381,,368,368,,368,381,,,,381,381,,381,381,,,,381,381,381,381,368,,,381',
+',,368,,368,,368,368,,368,368,368,,368,368,,,,,368,368,,,368,,,368,368',
+',,,,199,199,368,,199,199,,199,368,,,,368,368,,368,368,,,,368,368,368',
+'368,199,,,368,,,199,,199,,199,199,,199,199,199,,199,199,,,,,199,199',
+',,199,,,199,199,,,,,43,43,199,,43,43,,43,199,,,,199,199,,199,199,,,',
+'199,199,199,199,43,,,199,,,43,,43,,43,43,,43,43,43,,43,43,,,,,43,43',
+',,43,,,43,43,,,,,44,44,43,,44,44,,44,43,,,,43,43,,43,43,,,,43,43,43',
+'43,44,,,43,,,44,,44,,44,44,,44,44,44,,44,44,,,,,44,44,,,44,,,44,44,',
+',,,45,45,44,,45,45,,45,44,,,,44,44,,44,44,,,,44,44,44,44,45,,,44,,,45',
+',45,,45,45,,45,45,45,,45,45,,,,,45,45,,,45,,,45,45,,,,,46,46,45,,46',
+'46,,46,45,,,,45,45,,45,45,,,,45,45,45,45,46,,,45,,,46,,46,,46,46,,46',
+'46,46,,46,46,,,,,46,46,,,46,,,46,46,,,,,200,200,46,,200,200,,200,46',
+',,,46,46,,46,46,,,,46,46,46,46,200,,,46,,,200,,200,,200,200,,200,200',
+'200,,200,200,,,,,200,200,,,200,,,200,200,,,,,201,201,200,,201,201,,201',
+'200,,,,200,200,,200,200,,,,200,200,200,200,201,,,200,,,201,,201,,201',
+'201,,201,201,201,,201,201,,,,,201,201,,,201,,,201,201,,,,,351,351,201',
+',351,351,,351,201,,,,201,201,,201,201,,,,201,201,201,201,351,,,201,',
+',351,,351,,351,351,,351,351,351,,351,351,,,,,351,351,,,351,,174,351',
+'351,,,,,,,351,,,,,174,351,174,,174,351,351,,351,351,,,,351,351,351,351',
+'230,230,,351,230,230,,230,230,174,,,,,,,,,,,,,,,230,,,,,,230,174,230',
+',230,230,,230,230,230,,230,230,230,230,,,230,230,,,230,,,230,230,,,',
+',57,57,230,,57,57,57,57,230,,,,230,230,,230,230,,,,230,230,230,230,57',
+',,230,,,57,,57,,57,57,,57,57,57,,57,57,,,,,57,57,,,57,,,57,57,,,,,58',
+'58,57,,58,58,58,58,57,,,,57,57,,57,57,,,,57,57,57,57,58,,,57,,,58,,58',
+',58,58,,58,58,58,,58,58,,,,,58,58,,,58,,173,58,58,,,,,,,58,,,,,173,58',
+'173,,173,58,58,,58,58,,,,58,58,58,58,59,59,,58,59,59,,59,59,173,,,,',
+',,,,,,,,,,59,,,,,,59,173,59,,59,59,,59,59,59,,59,59,,,,,59,59,,,59,',
+',59,59,,,,,65,65,59,,65,65,,65,59,,,,59,59,,59,59,,,,59,59,59,59,65',
+',,59,,,65,,65,,65,65,,65,65,65,,65,65,,,,,65,65,,,65,,,65,65,,,221,221',
+'221,221,65,221,221,221,221,221,65,221,221,,65,65,,65,65,221,221,221',
+'65,65,65,65,244,244,,65,244,244,,244,244,180,,221,221,,,,,,,,,,,180',
+'244,180,,180,,,244,,244,,244,244,,244,244,244,,244,244,244,244,,,244',
+'244,180,,244,,,244,244,,180,180,180,180,,244,,180,180,,,244,,,180,244',
+'244,,244,244,,,,244,244,244,244,163,163,,244,163,163,,163,163,180,,',
+',172,,,,,,,,,,,163,,,172,,172,163,172,163,,163,163,,163,163,163,,163',
+'163,163,163,,,163,163,,,163,,172,163,163,,,,,70,70,163,,70,70,,70,163',
+',,,163,163,,163,163,,,,163,163,163,163,70,,,163,,,70,,70,,70,70,,70',
+'70,70,,70,70,,,,,70,70,,,70,,117,70,70,,,,,,,70,,,,,117,70,117,,117',
+'70,70,,70,70,,,,70,70,70,70,336,336,,70,336,336,,336,336,117,,,,,,,',
+',,,,,,,336,,,,,,336,,336,,336,336,,336,336,336,,336,336,336,336,,,336',
+'336,,,336,,,336,336,,,,,261,261,336,,261,261,261,261,336,,,,336,336',
+',336,336,,,,336,336,336,336,261,,,336,,,261,,261,,261,261,,261,261,261',
+',261,261,,,,,261,261,,,261,,,261,261,,,,,335,335,261,,335,335,,335,261',
+',,,261,261,,261,261,,,,261,261,261,261,335,,,261,,,335,,335,,335,335',
+',335,335,335,,335,335,335,335,,,335,335,,,335,,,335,335,,,,,81,81,335',
+',81,81,,81,335,,,,335,335,,335,335,,,,335,335,335,335,81,,,335,,,81',
+',81,,81,81,,81,81,81,,81,81,81,81,,,81,81,,,81,,,81,81,,,,,82,82,81',
+',82,82,,82,81,,,,81,81,,81,81,,,,81,81,81,81,82,,,81,,,82,,82,,82,82',
+',82,82,82,,82,82,82,82,,,82,82,,,82,,,82,82,,,,,83,83,82,,83,83,,83',
+'82,,,,82,82,,82,82,,,,82,82,82,82,83,,,82,,,83,,83,,83,83,,83,83,83',
+',83,83,83,83,,,83,83,,,83,,,83,83,,,,,84,84,83,,84,84,,84,83,,,,83,83',
+',83,83,,,,83,83,83,83,84,,,83,,,84,,84,,84,84,,84,84,84,,84,84,84,84',
+',,84,84,,,84,,,84,84,,,,,85,85,84,,85,85,,85,84,,,,84,84,,84,84,,,,84',
+'84,84,84,85,,,84,,,85,,85,,85,85,,85,85,85,,85,85,85,85,,,85,85,,,85',
+',,85,85,,,,,86,86,85,,86,86,,86,85,,,,85,85,,85,85,,,,85,85,85,85,86',
+',,85,,,86,,86,,86,86,,86,86,86,,86,86,,,,,86,86,,,86,,,86,86,,,,,87',
+'87,86,,87,87,,87,86,,,,86,86,,86,86,,,,86,86,86,86,87,,,86,,,87,,87',
+',87,87,,87,87,87,,87,87,,,,,87,87,,,87,,,87,87,,,,,88,88,87,,88,88,',
+'88,87,,,,87,87,,87,87,,,,87,87,87,87,88,,,87,,,88,,88,,88,88,,88,88',
+'88,,88,88,,,,,88,88,,,88,,,88,88,,,,,89,89,88,,89,89,,89,88,,,,88,88',
+',88,88,,,,88,88,88,88,89,,,88,,,89,,89,,89,89,,89,89,89,,89,89,,,,,89',
+'89,,,89,,,89,89,,,,,90,90,89,,90,90,,90,89,,,,89,89,,89,89,,,,89,89',
+'89,89,90,,,89,,,90,,90,,90,90,,90,90,90,,90,90,,,,,90,90,,,90,,,90,90',
+',,,,91,91,90,,91,91,,91,90,,,,90,90,,90,90,,,,90,90,90,90,91,,,90,,',
+'91,,91,,91,91,,91,91,91,,91,91,,,,,91,91,,,91,,,91,91,,,,,92,92,91,',
+'92,92,,92,91,,,,91,91,,91,91,,,,91,91,91,91,92,,,91,,,92,,92,,92,92',
+',92,92,92,,92,92,,,,,92,92,,,92,,,92,92,,,,,93,93,92,,93,93,,93,92,',
+',,92,92,,92,92,,,,92,92,92,92,93,,,92,,,93,,93,,93,93,,93,93,93,,93',
+'93,,,,,93,93,,,93,,,93,93,,,,,94,94,93,,94,94,,94,93,,,,93,93,,93,93',
+',,,93,93,93,93,94,,,93,,,94,,94,,94,94,,94,94,94,,94,94,,,,,94,94,,',
+'94,,,94,94,,,,,95,95,94,,95,95,,95,94,,,,94,94,,94,94,,,,94,94,94,94',
+'95,,,94,,,95,,95,,95,95,,95,95,95,,95,95,,,,,95,95,,,95,,,95,95,,,,',
+'96,96,95,,96,96,,96,95,,,,95,95,,95,95,,,,95,95,95,95,96,,,95,,,96,',
+'96,,96,96,,96,96,96,,96,96,,,,,96,96,,,96,,,96,96,,,,,97,97,96,,97,97',
+',97,96,,,,96,96,,96,96,,,,96,96,96,96,97,,,96,,,97,,97,,97,97,,97,97',
+'97,,97,97,,,,,97,97,,,97,,,97,97,,,,,98,98,97,,98,98,,98,97,,,,97,97',
+',97,97,,,,97,97,97,97,98,,,97,,,98,,98,,98,98,,98,98,98,,98,98,,,,,98',
+'98,,,98,,,98,98,,,,,99,99,98,,99,99,,99,98,,,,98,98,,98,98,,,,98,98',
+'98,98,99,,,98,,,99,,99,,99,99,,99,99,99,,99,99,,,,,99,99,,,99,,,99,99',
+',,,,100,100,99,,100,100,,100,99,,,,99,99,,99,99,,,,99,99,99,99,100,',
+',99,,,100,,100,,100,100,,100,100,100,,100,100,,,,,100,100,,,100,,,100',
+'100,,,,,101,101,100,,101,101,,101,100,,,,100,100,,100,100,,,,100,100',
+'100,100,101,,,100,,,101,,101,,101,101,,101,101,101,,101,101,,,,,101',
+'101,,,101,,,101,101,,,,,102,102,101,,102,102,,102,101,,,,101,101,,101',
+'101,,,,101,101,101,101,102,,,101,,,102,,102,,102,102,,102,102,102,,102',
+'102,,,,,102,102,,,102,,,102,102,,,,,103,103,102,,103,103,,103,102,,',
+',102,102,,102,102,,,,102,102,102,102,103,,,102,,,103,,103,,103,103,',
+'103,103,103,,103,103,,,,,103,103,,,103,,,103,103,,,,,104,104,103,,104',
+'104,,104,103,,,,103,103,,103,103,,,,103,103,103,103,104,,,103,,,104',
+',104,,104,104,,104,104,104,,104,104,,,,,104,104,,,104,,,104,104,,,,',
+'105,105,104,,105,105,,105,104,,,,104,104,,104,104,,,,104,104,104,104',
+'105,,,104,,,105,,105,,105,105,,105,105,105,,105,105,,,,,105,105,,,105',
+',,105,105,,,,,106,106,105,,106,106,,106,105,,,,105,105,,105,105,,,,105',
+'105,105,105,106,,,105,,,106,,106,,106,106,,106,106,106,,106,106,,,,',
+'106,106,,,106,,,106,106,,,,,107,107,106,,107,107,,107,106,,,,106,106',
+',106,106,,,,106,106,106,106,107,,,106,,,107,,107,,107,107,,107,107,107',
+',107,107,,,,,107,107,,,107,,,107,107,,,,,108,108,107,,108,108,,108,107',
+',,,107,107,,107,107,,,,107,107,107,107,108,,,107,,,108,,108,,108,108',
+',108,108,108,,108,108,,,,,108,108,,,108,,,108,108,,,291,291,291,291',
+'108,291,291,291,291,291,108,291,291,108,108,108,,108,108,291,291,291',
+'108,108,108,108,324,324,,108,324,324,,324,324,,,291,291,,,,,,,,,,,,324',
+',,,,,324,,324,,324,324,,324,324,324,,324,324,,,,,324,324,,,324,,,324',
+'324,,,,,110,110,324,,110,110,,110,324,,,,324,324,,324,324,,,,324,324',
+'324,324,110,,,324,,,110,110,110,110,110,110,110,110,110,110,,110,110',
+',,,,110,110,110,110,110,,,110,110,,,,,,,110,,,,,110,110,,,,110,110,',
+'110,110,,,,110,110,110,110,317,317,,110,317,317,,317,,,,,,,,,,,,,,,',
+',317,,,,,,317,,317,,317,317,,317,317,317,,317,317,,,,,317,317,,,317',
+',,317,317,,,,,112,112,317,,112,112,,112,317,,,,317,317,,317,317,,,,317',
+'317,317,317,112,,,317,,,112,,112,,112,112,,112,112,112,,112,112,,,,',
+'112,112,,,112,,,112,112,,,,,113,113,112,,113,113,,113,112,,,,112,112',
+',112,112,,,,112,112,112,112,113,,,112,,,113,,113,,113,113,,113,113,113',
+',113,113,,,,,113,113,,,113,,,113,113,,,,,314,314,113,,314,314,,314,113',
+',,,113,113,,113,113,,,,113,113,113,113,314,,,113,,,314,,314,,314,314',
+',314,314,314,,314,314,,,,,314,314,,,314,,,314,314,,,,,307,307,314,,307',
+'307,,307,314,,,,314,314,,314,314,,,,314,314,314,314,307,,,314,,,307',
+',307,,307,307,,307,307,307,,307,307,,,,,307,307,,,307,,,307,307,,,,',
+'293,293,307,,293,293,,293,307,,,,307,307,,307,307,,,,307,307,307,307',
+'293,,,307,,,293,,293,,293,293,,293,293,293,,293,293,,,,,293,293,,,293',
+',,293,293,,,,,292,292,293,,292,292,,292,293,,,,293,293,,293,293,,,,293',
+'293,293,293,292,,,293,,,292,,292,,292,292,,292,292,292,,292,292,,,,',
+'292,292,,,292,,,292,292,,,,,,,292,,,,,,292,,,,292,292,,292,292,,,,292',
+'292,292,292,245,245,,292,245,245,,245,245,,,,,,,,,,,,,,,,245,,,,,,245',
+',245,,245,245,,245,245,245,,245,245,245,245,,,245,245,,,245,,,245,245',
+',,,,119,119,245,,119,119,,119,245,,,,245,245,,245,245,,,,245,245,245',
+'245,119,119,,245,,,119,,119,,119,119,,119,119,119,,119,119,,,,,119,119',
+',,119,,,119,119,,,,,289,289,119,,289,289,,289,119,,,,119,119,,119,119',
+',,,119,119,119,119,289,,,119,,,289,,289,,289,289,,289,289,289,,289,289',
+',,,,289,289,,,289,,,289,289,,,,,283,283,289,,283,283,,283,289,,,,289',
+'289,,289,289,,,,289,289,289,289,283,,,289,,,283,,283,,283,283,,283,283',
+'283,,283,283,,,,,283,283,,,283,,,283,283,,,,,123,123,283,,123,123,,123',
+'283,,,,283,283,,283,283,,,,283,283,283,283,123,123,,283,,,123,,123,',
+'123,123,,123,123,123,,123,123,,,,,123,123,,,123,,,123,123,,,,,160,160',
 '123,,160,160,,160,123,,,,123,123,,123,123,,,,123,123,123,123,160,,,123',
 ',,160,,160,,160,160,,160,160,160,,160,160,160,160,,,160,160,,,160,,',
-'160,160,,,,,285,285,160,,285,285,,285,160,,,,160,160,,160,160,,,,160',
-'160,160,160,285,,,160,,,285,,285,,285,285,,285,285,285,,285,285,,,,',
-'285,285,,,285,,,285,285,,,,,300,300,285,,300,300,,300,285,,,,285,285',
-',285,285,,,,285,285,285,285,300,,,285,,,300,,300,,300,300,,300,300,300',
-',300,300,,,,,300,300,,,300,,,300,300,,,,,263,263,300,,263,263,,263,300',
-',,,300,300,,300,300,,,,300,300,300,300,263,,,300,,,263,,263,,263,263',
-',263,263,263,,263,263,,,,,263,263,,,263,,,263,263,,,,,254,254,263,,254',
-'254,254,254,263,,,,263,263,,263,263,,,,263,263,263,263,254,,,263,,,254',
-',254,,254,254,,254,254,254,,254,254,,,,,254,254,,,254,,,254,254,,,,',
-'130,130,254,,130,130,,130,254,,,,254,254,,254,254,,,,254,254,254,254',
-'130,,,254,,,130,,130,,130,130,,130,130,130,,130,130,,,,,130,130,,,130',
-',,130,130,,,,,256,256,130,,256,256,,256,130,,,,130,130,,130,130,,,,130',
-'130,130,130,256,,,130,,,256,,256,,256,256,,256,256,256,,256,256,,,,',
-'256,256,,,256,,,256,256,,,,,307,307,256,,307,307,,307,256,,,,256,256',
-',256,256,,,,256,256,256,256,307,,,256,,,307,,307,,307,307,,307,307,307',
-',307,307,,,,,307,307,,,307,,,307,307,,,,,,,307,,,,,,307,,,,307,307,',
-'307,307,,,,307,307,307,307,258,258,,307,258,258,,258,258,,,,,,,,,,,',
-',,,,258,,,,,,258,,258,,258,258,,258,258,258,,258,258,,,,,258,258,,,258',
-',,258,258,,,,,286,286,258,,286,286,,286,258,,,,258,258,,258,258,,,,258',
-'258,258,258,286,,,258,,,286,,286,,286,286,,286,286,286,,286,286,,,,',
-'286,286,,,286,,,286,286,,,,,,,286,,,,,,286,,,,286,286,,286,286,,,146',
-'286,286,286,286,,,,286,146,146,146,146,146,146,,146,,146,,,146,146,146',
-'146,,,,,,,,,,,,,,,,146,,,,146,146,,,146,146,146,146,146,146,,146,146',
-'128,,128,,,146,,,,128,128,128,128,128,128,,128,,128,,,128,128,128,128',
-',,146,,,,,,,,,,,,,128,,,,128,128,,,128,128,128,128,128,128,222,128,128',
-',,,,,128,222,222,222,222,222,222,,222,,222,,,222,222,222,222,,,,,,128',
-',,,,,,,,,222,,,,222,222,,,222,222,222,222,222,222,151,222,222,,,151',
-',,222,151,151,151,151,151,151,,151,,151,,,151,151,151,151,,,,,,222,',
-',,,,,,,,151,,,,151,151,,,151,151,151,151,151,151,,151,151,127,,127,',
-',151,,,,127,127,127,127,127,127,,127,,127,,,127,127,127,127,,,151,,',
-',,,,,,,,,,127,,,,127,127,,,127,127,127,127,127,127,155,127,127,,,,,',
-'127,155,155,155,155,155,155,,155,,155,,,155,155,155,155,,,,,,127,,,',
-',,,,,,155,,,,155,155,,,155,155,155,155,155,155,,155,155,126,,126,,,155',
-',,,126,126,126,126,126,126,,126,,126,,,126,126,126,126,,,155,,,,,,,',
-',,,,,126,,,,126,126,,,126,126,126,126,126,126,,126,126,,272,,272,,126',
-'272,,,,272,272,272,272,272,272,,272,,272,,,272,272,272,272,,126,,,,',
-',,,,,,,,,272,,,,272,272,,,272,272,272,272,272,272,,272,272,124,,124',
-',,272,,,,124,124,124,124,124,124,,124,,124,,,124,124,124,124,,,272,',
-',,,,,,,,,,,124,,,,124,124,,,124,124,124,124,124,124,118,124,124,,,,',
-',124,118,118,118,118,118,118,,118,,118,,118,118,118,118,118,,,,,,124',
-',,,,,,,,,118,,,,118,118,,,118,118,118,118,118,118,162,118,118,,,,,,118',
-'162,162,162,162,162,162,,162,,162,,,162,162,162,162,,,,,,118,,,,,,,',
-',,162,,,,162,162,,,162,162,162,162,162,162,330,162,162,,,,,,162,330',
-'330,330,330,330,330,,330,,330,162,162,330,330,330,330,,,,,,162,,,,,',
-',,,,330,,,,330,330,,,330,330,330,330,330,330,333,330,330,,,,,,330,333',
-'333,333,333,333,333,,333,,333,,,333,333,333,333,,,,,,330,,,,,,,,,,333',
-',,,333,333,,,333,333,333,333,333,333,339,333,333,,,,,,333,339,339,339',
-'339,339,339,,339,,339,,,339,339,339,339,,,,,,333,,,,,,,,,,339,,,,339',
-'339,,,339,339,339,339,339,339,347,339,339,,,,,,339,347,347,347,347,347',
-'347,,347,,347,,,347,347,347,347,,,,,,339,,,,,,,,,,347,,,,347,347,,,347',
-'347,347,347,347,347,348,347,347,,,,,,347,348,348,348,348,348,348,,348',
-',348,,,348,348,348,348,,,,,,347,,,,,,,,,,348,,,,348,348,,,348,348,348',
-'348,348,348,354,348,348,,,,,,348,354,354,354,354,354,354,,354,,354,',
-',354,354,354,354,,,,,,348,,,,,,,,,,354,,,,354,354,,,354,354,354,354',
-'354,354,198,354,354,,,,,,354,198,198,198,198,198,198,198,198,,198,,',
-'198,198,198,198,,,,,,354,,,,,,,,,,198,,,,198,198,,,198,198,198,198,198',
-'198,,198,198,11,,11,,,198,,,,11,11,11,11,11,11,,11,,11,,,11,11,11,11',
-',,198,,,,,,,,,,,,,11,,,,11,11,,,11,11,11,11,11,11,193,11,11,,,193,,',
-'11,193,193,193,193,193,193,,193,182,193,,,193,193,193,193,,,,,,11,182',
-',182,,182,,,,,193,,,,193,193,,,193,193,193,193,193,193,,193,193,182',
-',,183,,193,,,182,182,182,182,182,182,,182,182,183,,183,184,183,182,',
-',,,193,,,,,,184,184,,184,,184,,,184,,183,182,,,,,,,183,183,183,183,183',
-'183,,183,183,184,,,,,183,,185,184,184,184,184,184,184,,184,184,,,,185',
-'185,184,185,186,185,,183,185,,,,,,,,,186,186,,186,,186,,184,186,,185',
-'248,248,,,248,,,185,185,185,185,185,185,,185,185,186,,,,,185,,,186,186',
-'186,186,186,186,,186,186,,,192,,,186,248,,,248,185,192,192,192,192,192',
-'192,,192,,192,,,192,192,192,192,186,,248,,,,,,,,,,248,248,,192,,,,192',
-'192,,188,192,192,192,192,192,192,,192,192,,,188,188,188,192,188,,188',
-',189,188,188,188,188,,,,,,,,189,189,189,,189,192,189,,188,189,189,189',
-'189,,,,188,188,188,188,188,188,,188,188,,,,189,,188,,,189,,,189,189',
-'189,189,189,189,,189,189,190,,,,,189,,188,,190,190,190,190,190,190,',
-'190,,190,,,190,190,190,190,,,189,,,,,,,,,,,,,190,,,,190,190,,,190,190',
-'190,190,190,190,191,190,190,,,,,,190,191,191,191,191,191,191,,191,,191',
-',187,191,191,191,191,51,51,,,51,190,,,187,187,,187,,187,,191,187,,,191',
-'191,,,191,191,191,191,191,191,,191,191,250,250,,187,250,191,,51,,,51',
-'187,187,187,187,187,187,,187,187,177,,212,212,,187,212,191,,,51,,,,177',
-',177,178,177,250,51,51,250,,,,,187,,179,,178,,178,,178,,,,,177,212,250',
-'179,212,179,,179,,,,,250,250,,177,177,178,,,,,177,,212,,,,,179,,,178',
-'178,212,212,,,,178,,,,,179,179,,,,,,179' ]
-        racc_action_check = arr = ::Array.new(6903, nil)
+'160,160,,,,,246,246,160,,246,246,,246,160,,,,160,160,,160,160,,,,160',
+'160,160,160,246,,,160,,,246,,246,,246,246,,246,246,246,,246,246,,,,',
+'246,246,,,246,,,246,246,,,,,247,247,246,,247,247,,247,246,,,,246,246',
+',246,246,,,,246,246,246,246,247,,,246,,,247,247,247,247,247,247,247',
+'247,247,247,,247,247,,,,,247,247,247,247,247,,,247,247,,,,,,,247,,,',
+',247,247,,,,247,247,,247,247,,,,247,247,247,247,248,248,,247,248,248',
+',248,,,,,,,,,,,,,,,,,248,,,,,,248,,248,,248,248,,248,248,248,,248,248',
+',,,,248,248,,,248,,,248,248,,,,,282,282,248,,282,282,,282,248,,,,248',
+'248,,248,248,,,,248,248,248,248,282,,,248,,,282,,282,,282,282,,282,282',
+'282,,282,282,,,,,282,282,,,282,,,282,282,,,,,130,130,282,,130,130,,130',
+'282,,,,282,282,,282,282,,,,282,282,282,282,130,,,282,,,130,,130,,130',
+'130,,130,130,130,,130,130,,,,,130,130,,,130,,,130,130,,,,,259,259,130',
+',259,259,259,259,130,,,,130,130,,130,130,,,,130,130,130,130,259,,,130',
+',,259,,259,,259,259,,259,259,259,,259,259,,,,,259,259,,,259,,,259,259',
+',,,,270,270,259,,270,270,,270,259,,,,259,259,,259,259,,,,259,259,259',
+'259,270,,,259,,,270,,270,,270,270,,270,270,270,,270,270,,,,,270,270',
+',,270,,,270,270,,,,,,,270,,,,,,270,,,,270,270,,270,270,,,,270,270,270',
+'270,265,265,,270,265,265,,265,265,,,,,,,,,,,,,,,,265,,,,,,265,,265,',
+'265,265,,265,265,265,,265,265,,,,,265,265,,,265,,,265,265,,,,,263,263',
+'265,,263,263,,263,265,,,,265,265,,265,265,,,,265,265,265,265,263,,,265',
+',,263,,263,,263,263,,263,263,263,,263,263,,,,,263,263,,,263,,,263,263',
+',,,,79,79,263,,79,79,,79,263,,,,263,263,,263,263,,,,263,263,263,263',
+'79,,,263,,,79,,79,,79,79,,79,79,79,,79,79,79,79,,,79,79,,,79,,,79,79',
+',,,,,,79,,,,,,79,,,,79,79,,79,79,,,146,79,79,79,79,,,,79,146,146,146',
+'146,146,146,,146,,146,,,146,146,146,146,,,,,,,,,,,,,,,,146,,,,146,146',
+',,146,146,146,146,146,146,,146,146,,279,,279,,146,279,,,,279,279,279',
+'279,279,279,,279,,279,,,279,279,279,279,,146,,,,,,,,,,,,,,279,,,,279',
+'279,,,279,279,279,279,279,279,151,279,279,,,151,,,279,151,151,151,151',
+'151,151,,151,,151,,,151,151,151,151,,,,,,279,,,,,,,,,,151,,,,151,151',
+',,151,151,151,151,151,151,,151,151,128,,128,,,151,,,,128,128,128,128',
+'128,128,,128,,128,,,128,128,128,128,,,151,,,,,,,,,,,,,128,,,,128,128',
+',,128,128,128,128,128,128,155,128,128,,,,,,128,155,155,155,155,155,155',
+',155,,155,,,155,155,155,155,,,,,,128,,,,,,,,,,155,,,,155,155,,,155,155',
+'155,155,155,155,,155,155,127,,127,,,155,,,,127,127,127,127,127,127,',
+'127,,127,,,127,127,127,127,,,155,,,,,,,,,,,,,127,,,,127,127,,,127,127',
+'127,127,127,127,,127,127,126,,126,,,127,,,,126,126,126,126,126,126,',
+'126,,126,,,126,126,126,126,,,127,,,,,,,,,,,,,126,,,,126,126,,,126,126',
+'126,126,126,126,,126,126,124,,124,,,126,,,,124,124,124,124,124,124,',
+'124,,124,,,124,124,124,124,,,126,,,,,,,,,,,,,124,,,,124,124,,,124,124',
+'124,124,124,124,118,124,124,,,,,,124,118,118,118,118,118,118,,118,,118',
+',118,118,118,118,118,,,,,,124,,,,,,,,,,118,,,,118,118,,,118,118,118',
+'118,118,118,162,118,118,,,,,,118,162,162,162,162,162,162,,162,,162,',
+',162,162,162,162,,,,,,118,,,,,,,,,,162,,,,162,162,,,162,162,162,162',
+'162,162,340,162,162,,,,,,162,340,340,340,340,340,340,,340,,340,162,162',
+'340,340,340,340,,,,,,162,,,,,,,,,,340,,,,340,340,,,340,340,340,340,340',
+'340,343,340,340,,,,,,340,343,343,343,343,343,343,,343,,343,,,343,343',
+'343,343,,,,,,340,,,,,,,,,,343,,,,343,343,,,343,343,343,343,343,343,349',
+'343,343,,,,,,343,349,349,349,349,349,349,,349,,349,,,349,349,349,349',
+',,,,,343,,,,,,,,,,349,,,,349,349,,,349,349,349,349,349,349,222,349,349',
+',,,,,349,222,222,222,222,222,222,,222,,222,,,222,222,222,222,,,,,,349',
+',,,,,,,,,222,,,,222,222,,,222,222,222,222,222,222,357,222,222,,,,,,222',
+'357,357,357,357,357,357,,357,,357,,,357,357,357,357,,,,,,222,,,,,,,',
+',,357,,,,357,357,,,357,357,357,357,357,357,358,357,357,,,,,,357,358',
+'358,358,358,358,358,,358,,358,,,358,358,358,358,,,,,,357,,,,,,,,,,358',
+',,,358,358,,,358,358,358,358,358,358,364,358,358,,,,,,358,364,364,364',
+'364,364,364,,364,,364,,,364,364,364,364,,,,,,358,,,,,,,,,,364,,,,364',
+'364,,,364,364,364,364,364,364,198,364,364,,,,,,364,198,198,198,198,198',
+'198,198,198,,198,,,198,198,198,198,,,,,,364,,,,,,,,,,198,,,,198,198',
+',,198,198,198,198,198,198,,198,198,11,,11,,,198,,,,11,11,11,11,11,11',
+',11,181,11,,,11,11,11,11,,,198,,,,181,,181,,181,,,,,11,,,,11,11,,,11',
+'11,11,11,11,11,,11,11,181,,,182,,11,,,181,181,181,181,,,,181,181,182',
+',182,183,182,181,,,,,11,,,,,,,183,,183,,183,,,,,182,181,,,,,,,182,182',
+'182,182,182,182,,182,182,183,,,,,182,,184,183,183,183,183,183,183,,183',
+'183,,,,184,184,183,184,185,184,,182,184,,,,,,,,,185,185,,185,,185,,183',
+'185,,184,,,,,,,,184,184,184,184,184,184,,184,184,185,,,,,184,,186,185',
+'185,185,185,185,185,,185,185,,,,186,186,185,186,187,186,,184,186,,,',
+',,,,,187,187,,187,,187,,185,187,,186,,,,,,,,186,186,186,186,186,186',
+',186,186,187,,,,,186,,188,187,187,187,187,187,187,,187,187,,,188,188',
+'188,187,188,,188,,186,188,188,188,188,,,,,,,,,,,,,187,,,188,,,,,189',
+',,188,188,188,188,188,188,,188,188,189,189,189,,189,188,189,,190,189',
+'189,189,189,,,,,190,190,190,190,190,190,,190,,190,188,189,190,190,190',
+'190,189,,,189,189,189,189,189,189,,189,189,,,,190,,189,,190,190,,,190',
+'190,190,190,190,190,,190,190,191,,,,,190,,189,,191,191,191,191,191,191',
+',191,,191,,,191,191,191,191,,,190,,,,,,,,,,,,,191,,,,191,191,,,191,191',
+'191,191,191,191,193,191,191,,,193,,,191,193,193,193,193,193,193,,193',
+',193,,,193,193,193,193,,,,,,191,,,,,,,,,,193,,,,193,193,,,193,193,193',
+'193,193,193,192,193,193,,,,,,193,192,192,192,192,192,192,,192,,192,',
+',192,192,192,192,255,255,257,257,255,193,257,51,51,212,212,51,,212,',
+'192,,,,192,192,,,192,192,192,192,192,192,,192,192,,,,,177,192,,255,',
+'257,255,,257,,51,178,212,51,177,212,177,,177,,,,,192,,178,255,178,257',
+'178,,,,51,179,212,255,255,257,257,177,,,51,51,212,212,,179,,179,178',
+'179,,,177,177,,,,,,177,,,,178,178,,,,,,178,179,,,,,,,,,,,,,,,179,179',
+',,,,,179' ]
+        racc_action_check = arr = ::Array.new(7002, 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,   291,   nil,   nil,   nil,   142,   276,   nil,    75,   nil,
-   nil,  6295,   430,   490,   550,   610,   nil,   nil,   nil,   nil,
+    -2,   326,   nil,   nil,   nil,   142,   311,   nil,   176,   nil,
+   nil,  6355,   430,   490,   550,   610,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   254,   186,   228,   850,   910,   970,  1030,    49,   203,   nil,
-    69,  6757,   nil,   nil,   nil,   nil,   nil,  1354,  1414,  1498,
-   nil,   nil,   nil,   nil,   nil,  1558,   nil,   169,   172,   nil,
-  1738,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   238,  1858,
-   221,  2002,  2062,  2122,  2182,  2242,  2302,  2362,  2422,  2482,
-  2542,  2602,  2662,  2722,  2782,  2842,  2902,  2962,  3022,  3082,
-  3142,  3202,  3262,  3322,  3382,  3442,  3502,  3562,  3622,   189,
-  3766,   209,  3910,  3970,  1950,    83,  1906,    90,  5806,  4378,
-   nil,   181,   -10,  4606,  5752,   nil,  5637,  5526,  5361,    57,
-  4966,   163,   nil,   nil,   nil,   nil,   146,    -7,   nil,   140,
-   nil,   nil,   nil,   nil,   nil,   nil,  5304,    87,   nil,     7,
-   nil,  5469,    94,   nil,   nil,  5580,   nil,    13,   nil,    99,
-  4666,   -14,  5860,  1942,   nil,   117,   nil,   nil,   nil,   nil,
-   nil,    61,   318,  1462,  1358,     2,   230,  6804,  6821,  6833,
-  4118,  4466,  6366,  6409,  6426,  6473,  6490,  6747,  6596,  6616,
-  6673,  6727,  6549,  6349,   nil,   nil,   370,   nil,  6238,   790,
-  1150,  1210,    75,    96,   nil,   nil,    -1,   nil,    -9,    -4,
-    62,    26,  6811,     2,    -2,   nil,   nil,   nil,   nil,   nil,
-   nil,  3828,  5415,    99,   nil,   126,   nil,   141,   104,   nil,
-  4546,   nil,   188,   nil,   226,   -11,   nil,  4198,  4114,  4030,
-  1270,  1090,   205,   218,   nil,   -15,   188,   277,  6519,   nil,
-  6789,   -28,  4258,   nil,  4906,   nil,  5026,   nil,  5170,   nil,
-   nil,   nil,   nil,  4846,   nil,   nil,   nil,    83,   nil,   nil,
-   nil,   nil,  5695,    60,   nil,  4318,  1678,    99,   nil,   170,
-   nil,   119,  1798,   123,  3650,  4726,  5230,   145,   nil,   nil,
+   281,   220,   259,   850,   910,   970,  1030,    49,   233,   nil,
+    92,  6874,   nil,   nil,   nil,   nil,   nil,  1354,  1414,  1498,
+   nil,   nil,   nil,   nil,   nil,  1558,   nil,   181,   185,   nil,
+  1786,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   254,  5290,
+   237,  2050,  2110,  2170,  2230,  2290,  2350,  2410,  2470,  2530,
+  2590,  2650,  2710,  2770,  2830,  2890,  2950,  3010,  3070,  3130,
+  3190,  3250,  3310,  3370,  3430,  3490,  3550,  3610,  3670,   189,
+  3814,   184,  3958,  4018,   318,   113,    90,  1834,  5812,  4402,
+   nil,   101,    63,  4582,  5758,   nil,  5701,  5644,  5533,    20,
+  4966,    14,   nil,   nil,   nil,   nil,   129,    56,   nil,   148,
+   nil,   nil,   nil,   nil,   nil,   nil,  5364,    87,   nil,    66,
+   nil,  5476,    92,   nil,   nil,  5587,   nil,   137,   nil,    16,
+  4642,   104,  5866,  1726,   nil,   267,   nil,   nil,   nil,   nil,
+   nil,    93,  1734,  1462,  1258,     2,   230,  6898,  6909,  6932,
+  1646,  6372,  6415,  6432,  6479,  6496,  6543,  6560,  6607,  6652,
+  6672,  6729,  6837,  6783,   nil,   nil,   370,   nil,  6298,   790,
+  1090,  1150,   222,   177,   nil,   nil,    -1,   nil,    -2,    -9,
+   106,   121,  6876,     2,    -4,   nil,   nil,   nil,   nil,   nil,
+   nil,  1586,  6082,    82,   nil,    80,   nil,    53,   118,   nil,
+  1294,   nil,   260,   nil,   nil,   nil,   nil,   nil,   273,   287,
+   -24,   279,   -11,   nil,  1642,  4342,  4702,  4762,  4846,   219,
+   210,   nil,   -21,   209,   191,  6867,   nil,  6869,   -28,  5026,
+   nil,  1930,   nil,  5230,   nil,  5170,   nil,   nil,   nil,   nil,
+  5086,   nil,   nil,   nil,   123,   nil,   nil,   nil,   nil,  5422,
+   271,   nil,  4906,  4522,    65,   nil,   170,   nil,    97,  4462,
+   114,  3698,  4258,  4198,   150,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,  4138,   146,   nil,
+   167,   nil,   109,    60,  4078,   nil,   nil,  3898,   nil,   187,
+   161,   191,   182,     4,  3754,   nil,   192,   225,   203,   236,
+   238,   nil,    26,   nil,   236,  1990,  1870,   nil,   nil,   nil,
+  5920,   nil,   nil,  5974,   nil,   nil,   nil,   188,   -60,  6028,
+   258,  1210,   261,   nil,   nil,   nil,   nil,  6136,  6190,    21,
+   213,   nil,   nil,   nil,  6244,    90,   137,   nil,   730,   285,
+   262,   nil,   288,   289,   nil,   nil,   nil,   292,   295,   296,
+   nil,   670,   nil,   nil,   nil,   287,   308,   nil,   nil,   312,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-  4786,   135,   nil,   153,   nil,    98,   134,  5086,   nil,   163,
-   101,   167,   147,     6,  4462,   nil,   151,   181,   154,    30,
-   191,   nil,    -8,   nil,   202,  3850,  3706,   nil,   nil,   nil,
-  5914,   nil,   nil,  5968,   nil,   nil,   nil,   170,    -2,  6022,
-   234,  1618,   233,   nil,   nil,   nil,   nil,  6076,  6130,   239,
-   179,   nil,   nil,   nil,  6184,   120,   nil,   730,   250,   228,
-   nil,   255,   259,   nil,   nil,   nil,   263,   264,   268,   nil,
-   670,   nil,   nil,   nil,   254,   274,   nil,   nil,   275,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   310,
-   nil,   226,    82,   nil,   nil,   nil,   284,   nil,   nil,   nil,
-   285,   nil,   287,   nil,   288,   nil,   nil,   nil,   nil,   nil ]
+   nil,   310,   nil,   226,    82,   nil,   nil,   nil,   317,   nil,
+   nil,   nil,   318,   nil,   319,   nil,   320,   nil,   nil,   nil,
+   nil,   nil ]
 
 racc_action_default = [
-  -236,  -237,    -1,    -2,    -3,    -4,    -5,    -8,   -10,   -11,
-   -16,  -109,  -237,  -237,  -237,  -237,   -46,   -47,   -48,   -49,
+  -244,  -245,    -1,    -2,    -3,    -4,    -5,    -8,   -10,   -11,
+   -16,  -109,  -245,  -245,  -245,  -245,   -46,   -47,   -48,   -49,
    -50,   -51,   -52,   -53,   -54,   -55,   -56,   -57,   -58,   -59,
    -60,   -61,   -62,   -63,   -64,   -65,   -66,   -67,   -68,   -69,
-   -74,   -75,   -79,  -237,  -237,  -237,  -237,  -237,  -120,  -122,
-  -237,  -237,  -169,  -170,  -171,  -172,  -173,  -237,  -237,  -237,
-  -186,  -187,  -188,  -189,  -190,  -237,  -192,  -237,  -203,  -206,
-  -237,  -211,  -212,  -213,  -214,  -215,  -216,  -217,  -237,  -237,
-    -7,  -237,  -237,  -237,  -237,  -237,  -237,  -237,  -237,  -237,
-  -237,  -237,  -237,  -237,  -237,  -237,  -237,  -237,  -237,  -237,
-  -237,  -237,  -237,  -237,  -237,  -237,  -237,  -237,  -237,  -237,
-  -129,  -124,  -236,  -236,   -28,  -237,   -29,   -36,  -237,  -237,
-   -76,  -237,  -237,  -237,  -237,   -86,  -237,  -237,  -237,  -237,
-  -237,  -236,  -139,  -160,  -161,  -121,  -236,  -236,  -148,  -150,
-  -151,  -152,  -153,  -154,  -156,  -157,   -44,  -237,  -176,  -237,
-  -179,  -237,  -237,  -182,  -183,  -196,  -191,  -237,  -199,  -237,
-  -237,  -237,  -237,  -237,   410,    -6,    -9,   -12,   -13,   -14,
-   -15,  -237,   -18,   -19,   -20,   -21,   -22,   -23,   -24,   -25,
+   -74,   -75,   -79,  -245,  -245,  -245,  -245,  -245,  -120,  -122,
+  -245,  -245,  -177,  -178,  -179,  -180,  -181,  -245,  -245,  -245,
+  -194,  -195,  -196,  -197,  -198,  -245,  -200,  -245,  -211,  -214,
+  -245,  -219,  -220,  -221,  -222,  -223,  -224,  -225,  -245,  -245,
+    -7,  -245,  -245,  -245,  -245,  -245,  -245,  -245,  -245,  -245,
+  -245,  -245,  -245,  -245,  -245,  -245,  -245,  -245,  -245,  -245,
+  -245,  -245,  -245,  -245,  -245,  -245,  -245,  -245,  -245,  -245,
+  -129,  -124,  -244,  -244,   -28,  -245,   -29,   -36,  -245,  -245,
+   -76,  -245,  -245,  -245,  -245,   -86,  -245,  -245,  -245,  -245,
+  -245,  -244,  -139,  -160,  -161,  -121,  -244,  -244,  -148,  -150,
+  -151,  -152,  -153,  -154,  -156,  -157,   -44,  -245,  -184,  -245,
+  -187,  -245,  -245,  -190,  -191,  -204,  -199,  -245,  -207,  -245,
+  -245,  -245,  -245,  -245,   422,    -6,    -9,   -12,   -13,   -14,
+   -15,  -245,   -18,   -19,   -20,   -21,   -22,   -23,   -24,   -25,
    -26,   -27,   -30,   -31,   -32,   -33,   -34,   -35,   -37,   -38,
-   -39,   -40,   -41,  -237,   -42,  -104,  -237,   -80,  -237,  -229,
-  -235,  -223,  -220,  -218,  -118,  -130,  -212,  -133,  -216,  -237,
-  -226,  -224,  -232,  -214,  -215,  -222,  -227,  -228,  -230,  -231,
-  -233,  -129,  -128,  -237,  -127,  -237,   -43,  -218,   -71,   -81,
-  -237,   -84,  -218,  -165,  -168,  -237,   -78,  -237,  -237,  -237,
-  -129,  -237,  -220,  -236,  -162,  -237,  -237,  -237,  -237,  -158,
-  -237,  -237,  -237,  -174,  -237,  -177,  -237,  -180,  -237,  -193,
-  -194,  -195,  -197,  -237,  -200,  -201,  -202,  -218,  -204,  -207,
-  -209,  -210,  -109,  -237,   -17,  -237,  -237,  -218,  -106,  -129,
-  -117,  -237,  -221,  -237,  -219,  -237,  -237,  -218,  -132,  -134,
-  -223,  -224,  -225,  -226,  -229,  -232,  -234,  -235,  -125,  -126,
-  -219,  -237,   -73,  -237,   -83,  -237,  -219,  -237,   -77,  -237,
-   -89,  -237,   -95,  -237,  -237,   -99,  -220,  -218,  -220,  -237,
-  -237,  -142,  -237,  -163,  -218,  -236,  -237,  -149,  -159,  -155,
-   -45,  -175,  -178,  -185,  -181,  -184,  -198,  -237,  -237,  -108,
-  -237,  -219,  -218,  -112,  -119,  -113,  -131,  -135,  -136,  -237,
-   -70,   -82,   -85,  -166,  -167,   -89,   -88,  -237,  -237,   -95,
-   -94,  -237,  -237,  -103,   -98,  -100,  -237,  -237,  -237,  -115,
-  -236,  -143,  -144,  -145,  -237,  -237,  -140,  -141,  -237,  -147,
-  -205,  -208,  -105,  -107,  -116,  -123,   -72,   -87,   -90,  -237,
-   -93,  -237,  -237,  -110,  -111,  -114,  -237,  -164,  -137,  -146,
-  -237,   -92,  -237,   -97,  -237,  -102,  -138,   -91,   -96,  -101 ]
+   -39,   -40,   -41,  -245,   -42,  -104,  -245,   -80,  -245,  -237,
+  -243,  -231,  -228,  -226,  -118,  -130,  -220,  -133,  -224,  -245,
+  -234,  -232,  -240,  -222,  -223,  -230,  -235,  -236,  -238,  -239,
+  -241,  -129,  -128,  -245,  -127,  -245,   -43,  -226,   -71,   -81,
+  -245,   -84,  -226,  -165,  -167,  -168,  -169,  -170,  -172,  -245,
+  -245,  -175,  -245,   -78,  -245,  -245,  -245,  -129,  -245,  -228,
+  -244,  -162,  -245,  -245,  -245,  -245,  -158,  -245,  -245,  -245,
+  -182,  -245,  -185,  -245,  -188,  -245,  -201,  -202,  -203,  -205,
+  -245,  -208,  -209,  -210,  -226,  -212,  -215,  -217,  -218,  -109,
+  -245,   -17,  -245,  -245,  -226,  -106,  -129,  -117,  -245,  -229,
+  -245,  -227,  -245,  -245,  -226,  -132,  -134,  -231,  -232,  -233,
+  -234,  -237,  -240,  -242,  -243,  -125,  -126,  -227,  -245,   -73,
+  -245,   -83,  -245,  -227,  -245,  -173,  -174,  -245,   -77,  -245,
+   -89,  -245,   -95,  -245,  -245,   -99,  -228,  -226,  -228,  -245,
+  -245,  -142,  -245,  -163,  -226,  -244,  -245,  -149,  -159,  -155,
+   -45,  -183,  -186,  -193,  -189,  -192,  -206,  -245,  -245,  -108,
+  -245,  -227,  -226,  -112,  -119,  -113,  -131,  -135,  -136,  -245,
+   -70,   -82,   -85,  -166,  -171,  -245,   -89,   -88,  -245,  -245,
+   -95,   -94,  -245,  -245,  -103,   -98,  -100,  -245,  -245,  -245,
+  -115,  -244,  -143,  -144,  -145,  -245,  -245,  -140,  -141,  -245,
+  -147,  -213,  -216,  -105,  -107,  -116,  -123,   -72,  -176,   -87,
+   -90,  -245,   -93,  -245,  -245,  -110,  -111,  -114,  -245,  -164,
+  -137,  -146,  -245,   -92,  -245,   -97,  -245,  -102,  -138,   -91,
+   -96,  -101 ]
 
 racc_goto_table = [
      2,   136,     4,   120,   114,   116,   117,   118,   142,   140,
-   269,   156,   203,   202,   232,   281,   360,   243,   195,   375,
-   356,   327,   246,   328,   223,   225,   315,   229,   166,    80,
-   344,   279,   194,   242,   346,   124,   126,   127,   128,   167,
-   168,   169,   170,   283,   362,   277,   147,   149,   314,   146,
-   146,   151,   320,   267,   371,   319,   247,   155,   388,   329,
-   353,   335,   162,   390,   396,   387,   264,   301,   265,     3,
-   262,   263,   305,   261,   158,   171,   160,     1,   146,   172,
+   147,   149,   156,   195,   241,   276,   232,   288,   371,   203,
+   202,   367,   386,   250,   337,   325,   338,   330,   253,   223,
+   225,   166,    80,   354,   286,   124,   126,   127,   128,   171,
+   249,   167,   168,   169,   170,   284,   356,   229,   373,   146,
+   146,   151,   324,   241,   194,   274,   382,   155,   254,   400,
+   339,   363,   162,   316,   329,   315,   402,   399,   408,   345,
+   271,   272,   227,     3,   269,   270,   242,   268,   146,   172,
    173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
    183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-   193,   365,   198,   165,   222,   222,   278,   337,   227,   nil,
-   nil,   146,   235,   nil,   nil,   146,   nil,   340,   nil,   nil,
-   nil,   nil,   198,   287,   nil,   nil,   nil,   349,   nil,   366,
-   nil,   368,   nil,   244,   nil,   nil,   nil,   324,   244,   249,
-   nil,   nil,   317,   316,   318,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   272,   nil,   367,   nil,   nil,
-   266,   136,   nil,   273,   374,   nil,   nil,   nil,   nil,   142,
+   193,   285,   198,   376,   222,   222,   165,   158,   160,     1,
+   nil,   146,   nil,   nil,   nil,   146,   nil,   nil,   290,   nil,
+   nil,   nil,   198,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   294,   nil,   nil,   251,   nil,   nil,   nil,   nil,   251,   256,
+   nil,   377,   308,   379,   241,   nil,   334,   312,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   279,   327,   326,   328,   nil,
+   273,   136,   nil,   280,   nil,   nil,   nil,   nil,   nil,   142,
    140,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   342,   384,   nil,   nil,   nil,   381,   nil,   193,   nil,
-   302,   124,   126,   127,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   142,   140,   142,   140,   336,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   193,   347,
+   309,   124,   126,   127,   nil,   352,   nil,   nil,   nil,   350,
+   nil,   392,   nil,   nil,   nil,   241,   nil,   nil,   nil,   359,
+   nil,   nil,   142,   140,   142,   140,   nil,   346,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   303,   146,   198,   198,   nil,   nil,   nil,   309,   311,   nil,
-   nil,   nil,   nil,   nil,   330,   321,   330,   nil,   333,   nil,
-   151,   383,   nil,   nil,   nil,   155,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   330,   339,   nil,
-   nil,   nil,   nil,   372,   198,   nil,   nil,   347,   348,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   330,   nil,   nil,   nil,   nil,   nil,   nil,   354,
+   310,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   146,   198,
+   198,   nil,   378,   nil,   319,   321,   nil,   nil,   nil,   385,
+   nil,   340,   331,   340,   nil,   343,   394,   151,   nil,   nil,
+   nil,   nil,   155,   nil,   nil,   nil,   nil,   395,   nil,   nil,
+   365,   nil,   nil,   nil,   340,   349,   nil,   nil,   nil,   nil,
+   nil,   198,   nil,   383,   357,   358,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   340,
+   nil,   nil,   nil,   nil,   nil,   nil,   364,   nil,   nil,   146,
    nil,   nil,   nil,   nil,   nil,   nil,   146,   nil,   nil,   nil,
-   nil,   nil,   386,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   378,   377,   nil,   nil,
+   nil,   nil,   397,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   389,   388,   nil,   nil,
    nil,   nil,   nil,   193,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   124,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   124,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   388,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   377,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   400,
-   nil,   402,   404 ]
+   nil,   412,   nil,   414,   416 ]
 
 racc_goto_check = [
      2,    65,     4,    40,    10,    10,    10,    10,    32,    38,
-    90,    83,    57,    55,    45,    56,    48,    66,    52,    67,
-    47,    73,    66,    73,    61,    61,    50,    44,     7,     6,
-    58,    59,    13,    55,    62,    10,    10,    10,    10,     8,
-     8,     8,     8,    39,    51,    53,    12,    12,    49,    10,
-    10,    10,    69,    45,    70,    56,    72,    10,    46,    75,
-    76,    78,    10,    48,    67,    47,    79,    39,    80,     3,
-    84,    85,    39,    87,    88,    12,    89,     1,    10,    10,
+    12,    12,    88,    52,    35,    95,    45,    56,    48,    57,
+    55,    47,    67,    66,    73,    50,    73,    69,    66,    61,
+    61,     7,     6,    58,    59,    10,    10,    10,    10,    12,
+    55,     8,     8,     8,     8,    53,    62,    44,    51,    10,
+    10,    10,    49,    35,    13,    45,    70,    10,    72,    46,
+    75,    76,    10,    77,    56,    79,    48,    47,    67,    83,
+    84,    85,    12,     3,    89,    90,    12,    92,    10,    10,
     10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
     10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
-    10,    50,    10,     6,    10,    10,    52,    39,    12,   nil,
-   nil,    10,    12,   nil,   nil,    10,   nil,    39,   nil,   nil,
-   nil,   nil,    10,    57,   nil,   nil,   nil,    39,   nil,    56,
-   nil,    56,   nil,     4,   nil,   nil,   nil,    45,     4,     4,
-   nil,   nil,    57,    55,    55,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,    10,   nil,    39,   nil,   nil,
-     2,    65,   nil,     2,    39,   nil,   nil,   nil,   nil,    32,
+    10,    52,    10,    50,    10,    10,     6,    93,    94,     1,
+   nil,    10,   nil,   nil,   nil,    10,   nil,   nil,    39,   nil,
+   nil,   nil,    10,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    57,   nil,   nil,     4,   nil,   nil,   nil,   nil,     4,     4,
+   nil,    56,    39,    56,    35,   nil,    45,    39,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,    10,    57,    55,    55,   nil,
+     2,    65,   nil,     2,   nil,   nil,   nil,   nil,   nil,    32,
     38,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    57,    39,   nil,   nil,   nil,    90,   nil,    10,   nil,
-    40,    10,    10,    10,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,    32,    38,    32,    38,    83,
-   nil,   nil,   nil,   nil,   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,   nil,
-    10,    52,   nil,   nil,   nil,    10,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,    10,    10,   nil,
-   nil,   nil,   nil,    65,    10,   nil,   nil,    10,    10,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    10,    39,
+    40,    10,    10,    10,   nil,    57,   nil,   nil,   nil,    39,
+   nil,    95,   nil,   nil,   nil,    35,   nil,   nil,   nil,    39,
+   nil,   nil,    32,    38,    32,    38,   nil,    88,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    10,   nil,   nil,   nil,   nil,   nil,   nil,    10,
+     2,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    10,    10,
+    10,   nil,    39,   nil,     2,     2,   nil,   nil,   nil,    39,
+   nil,    10,     4,    10,   nil,    10,    52,    10,   nil,   nil,
+   nil,   nil,    10,   nil,   nil,   nil,   nil,    39,   nil,   nil,
+    12,   nil,   nil,   nil,    10,    10,   nil,   nil,   nil,   nil,
+   nil,    10,   nil,    65,    10,    10,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    10,
+   nil,   nil,   nil,   nil,   nil,   nil,    10,   nil,   nil,    10,
    nil,   nil,   nil,   nil,   nil,   nil,    10,   nil,   nil,   nil,
    nil,   nil,    40,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,     2,     4,   nil,   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,
+    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,   nil,
-   nil,   nil,     4,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     2,
-   nil,     2,     2 ]
+   nil,     2,   nil,     2,     2 ]
 
 racc_goto_pointer = [
-   nil,    77,     0,    69,     2,   nil,    24,   -53,   -43,   nil,
-    -8,   nil,   -11,   -76,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   109,     0,    73,     2,   nil,    27,   -50,   -41,   nil,
+    -8,   nil,   -47,   -54,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   -43,   nil,   nil,   nil,   nil,   nil,   -42,  -160,
-   -38,   nil,   nil,   nil,   -94,  -108,  -299,  -290,  -296,  -191,
-  -213,  -269,   -90,  -151,   nil,   -97,  -187,   -98,  -252,  -167,
-   nil,   -88,  -250,   nil,   nil,   -49,  -114,  -306,   nil,  -191,
-  -268,   nil,   -81,  -227,   nil,  -192,  -246,   nil,  -197,   -93,
-   -91,   nil,   nil,   -54,   -87,   -86,   nil,   -84,     7,     8,
-  -152 ]
+   nil,   nil,   -43,   nil,   nil,  -108,   nil,   nil,   -42,   -85,
+   -38,   nil,   nil,   nil,   -74,  -106,  -309,  -299,  -304,  -194,
+  -221,  -275,   -95,  -151,   nil,   -90,  -185,   -91,  -256,  -164,
+   nil,   -83,  -245,   nil,   nil,   -49,  -108,  -313,   nil,  -223,
+  -276,   nil,   -79,  -231,   nil,  -198,  -252,  -177,   nil,  -174,
+   nil,   nil,   nil,  -196,   -89,   -88,   nil,   nil,   -53,   -83,
+   -82,   nil,   -80,    40,    40,  -147 ]
 
 racc_goto_default = [
-   nil,   nil,   376,   nil,   224,     5,     6,     7,     8,     9,
-    11,    10,   313,   nil,    16,    40,    17,    18,    19,    20,
+   nil,   nil,   387,   nil,   224,     5,     6,     7,     8,     9,
+    11,    10,   323,   nil,    16,    40,    17,    18,    19,    20,
     21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
     31,    32,    33,    34,    35,    36,    37,    38,    39,   nil,
    nil,    41,    42,   121,   nil,   nil,   125,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,    46,   nil,   nil,   nil,   204,   nil,
    111,   nil,   205,   209,   207,   132,   nil,   nil,   131,   nil,
-   nil,   137,   nil,   138,   139,   143,   233,   152,   154,    60,
-    61,    62,    65,   nil,   nil,   nil,   157,   nil,   nil,   nil,
-   nil ]
+   nil,   137,   nil,   138,   139,   143,   233,   234,   235,   236,
+   237,   240,   152,   154,    60,    61,    62,    65,   nil,   nil,
+   nil,   157,   nil,   nil,   nil,   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
   1, 95, :_reduce_1,
   1, 95, :_reduce_2,
   1, 95, :_reduce_none,
   1, 96, :_reduce_4,
   1, 99, :_reduce_5,
   3, 99, :_reduce_6,
   2, 99, :_reduce_7,
   1, 100, :_reduce_8,
   3, 100, :_reduce_9,
   1, 101, :_reduce_none,
   1, 102, :_reduce_11,
   3, 102, :_reduce_12,
   3, 102, :_reduce_13,
   3, 102, :_reduce_14,
   3, 102, :_reduce_15,
   1, 104, :_reduce_none,
   4, 104, :_reduce_17,
   3, 104, :_reduce_18,
   3, 104, :_reduce_19,
   3, 104, :_reduce_20,
   3, 104, :_reduce_21,
   3, 104, :_reduce_22,
   3, 104, :_reduce_23,
   3, 104, :_reduce_24,
   3, 104, :_reduce_25,
   3, 104, :_reduce_26,
   3, 104, :_reduce_27,
   2, 104, :_reduce_28,
   2, 104, :_reduce_29,
   3, 104, :_reduce_30,
   3, 104, :_reduce_31,
   3, 104, :_reduce_32,
   3, 104, :_reduce_33,
   3, 104, :_reduce_34,
   3, 104, :_reduce_35,
   2, 104, :_reduce_36,
   3, 104, :_reduce_37,
   3, 104, :_reduce_38,
   3, 104, :_reduce_39,
   3, 104, :_reduce_40,
   3, 104, :_reduce_41,
   3, 104, :_reduce_42,
   3, 104, :_reduce_43,
   1, 106, :_reduce_44,
   3, 106, :_reduce_45,
   1, 105, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 109, :_reduce_none,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
   1, 127, :_reduce_68,
   1, 127, :_reduce_69,
   5, 108, :_reduce_70,
   3, 108, :_reduce_71,
   6, 108, :_reduce_72,
   4, 108, :_reduce_73,
   1, 108, :_reduce_74,
   1, 112, :_reduce_75,
   2, 112, :_reduce_76,
   4, 135, :_reduce_77,
   3, 135, :_reduce_78,
   1, 135, :_reduce_79,
   3, 136, :_reduce_80,
   2, 134, :_reduce_81,
   3, 138, :_reduce_82,
   2, 138, :_reduce_83,
   2, 137, :_reduce_84,
   4, 137, :_reduce_85,
   2, 115, :_reduce_86,
   5, 140, :_reduce_87,
   4, 140, :_reduce_88,
   0, 141, :_reduce_none,
   2, 141, :_reduce_90,
   4, 141, :_reduce_91,
   3, 141, :_reduce_92,
   6, 116, :_reduce_93,
   5, 116, :_reduce_94,
   0, 142, :_reduce_none,
   4, 142, :_reduce_96,
   3, 142, :_reduce_97,
   5, 114, :_reduce_98,
   1, 143, :_reduce_99,
   2, 143, :_reduce_100,
   5, 144, :_reduce_101,
   4, 144, :_reduce_102,
   1, 145, :_reduce_103,
   1, 107, :_reduce_none,
   4, 107, :_reduce_105,
   1, 147, :_reduce_106,
   3, 147, :_reduce_107,
   3, 146, :_reduce_108,
   1, 103, :_reduce_109,
   6, 103, :_reduce_110,
   6, 103, :_reduce_111,
   5, 103, :_reduce_112,
   5, 103, :_reduce_113,
   6, 103, :_reduce_114,
   5, 103, :_reduce_115,
   4, 152, :_reduce_116,
   1, 153, :_reduce_117,
   1, 149, :_reduce_118,
   3, 149, :_reduce_119,
   1, 148, :_reduce_120,
   2, 148, :_reduce_121,
   1, 148, :_reduce_122,
   6, 113, :_reduce_123,
   2, 113, :_reduce_124,
   3, 154, :_reduce_125,
   3, 154, :_reduce_126,
   1, 155, :_reduce_none,
   1, 155, :_reduce_none,
   0, 151, :_reduce_129,
   1, 151, :_reduce_130,
   3, 151, :_reduce_131,
   1, 157, :_reduce_none,
   1, 157, :_reduce_none,
   1, 157, :_reduce_none,
   3, 156, :_reduce_135,
   3, 156, :_reduce_136,
   6, 117, :_reduce_137,
   7, 118, :_reduce_138,
   1, 162, :_reduce_139,
   1, 161, :_reduce_none,
   1, 161, :_reduce_none,
   1, 163, :_reduce_none,
   2, 163, :_reduce_143,
   1, 164, :_reduce_none,
   1, 164, :_reduce_none,
   6, 119, :_reduce_146,
   5, 119, :_reduce_147,
   1, 165, :_reduce_148,
   3, 165, :_reduce_149,
   1, 167, :_reduce_150,
   1, 167, :_reduce_151,
   1, 167, :_reduce_152,
   1, 167, :_reduce_none,
   1, 168, :_reduce_154,
   3, 168, :_reduce_155,
   1, 169, :_reduce_none,
   1, 169, :_reduce_none,
   1, 166, :_reduce_none,
   2, 166, :_reduce_159,
   1, 159, :_reduce_160,
   1, 159, :_reduce_161,
   1, 160, :_reduce_162,
   2, 160, :_reduce_163,
   4, 160, :_reduce_164,
   1, 139, :_reduce_165,
   3, 139, :_reduce_166,
-  3, 170, :_reduce_167,
-  1, 170, :_reduce_168,
-  1, 111, :_reduce_169,
-  1, 121, :_reduce_170,
-  1, 121, :_reduce_171,
-  1, 121, :_reduce_172,
-  1, 121, :_reduce_173,
-  3, 122, :_reduce_174,
-  4, 122, :_reduce_175,
-  2, 122, :_reduce_176,
-  3, 122, :_reduce_177,
-  4, 122, :_reduce_178,
-  2, 122, :_reduce_179,
-  3, 125, :_reduce_180,
-  4, 125, :_reduce_181,
-  2, 125, :_reduce_182,
-  1, 171, :_reduce_183,
-  3, 171, :_reduce_184,
-  3, 172, :_reduce_185,
+  1, 170, :_reduce_none,
+  1, 170, :_reduce_none,
+  1, 171, :_reduce_none,
+  1, 171, :_reduce_none,
+  3, 173, :_reduce_171,
+  1, 173, :_reduce_172,
+  2, 174, :_reduce_173,
+  2, 172, :_reduce_174,
+  1, 175, :_reduce_175,
+  4, 175, :_reduce_176,
+  1, 111, :_reduce_177,
+  1, 121, :_reduce_178,
+  1, 121, :_reduce_179,
+  1, 121, :_reduce_180,
+  1, 121, :_reduce_181,
+  3, 122, :_reduce_182,
+  4, 122, :_reduce_183,
+  2, 122, :_reduce_184,
+  3, 122, :_reduce_185,
+  4, 122, :_reduce_186,
+  2, 122, :_reduce_187,
+  3, 125, :_reduce_188,
+  4, 125, :_reduce_189,
+  2, 125, :_reduce_190,
+  1, 176, :_reduce_191,
+  3, 176, :_reduce_192,
+  3, 177, :_reduce_193,
   1, 132, :_reduce_none,
   1, 132, :_reduce_none,
   1, 132, :_reduce_none,
-  1, 173, :_reduce_189,
-  1, 173, :_reduce_190,
-  2, 174, :_reduce_191,
-  1, 176, :_reduce_192,
-  1, 178, :_reduce_193,
-  1, 179, :_reduce_194,
-  2, 177, :_reduce_195,
-  1, 180, :_reduce_196,
-  1, 181, :_reduce_197,
-  2, 181, :_reduce_198,
-  2, 175, :_reduce_199,
-  2, 182, :_reduce_200,
-  2, 182, :_reduce_201,
-  3, 97, :_reduce_202,
-  0, 183, :_reduce_203,
-  2, 183, :_reduce_204,
-  4, 183, :_reduce_205,
-  1, 120, :_reduce_206,
-  3, 120, :_reduce_207,
-  5, 120, :_reduce_208,
-  1, 184, :_reduce_none,
-  1, 184, :_reduce_none,
-  1, 128, :_reduce_211,
-  1, 131, :_reduce_212,
-  1, 129, :_reduce_213,
-  1, 130, :_reduce_214,
-  1, 124, :_reduce_215,
-  1, 123, :_reduce_216,
-  1, 126, :_reduce_217,
+  1, 178, :_reduce_197,
+  1, 178, :_reduce_198,
+  2, 179, :_reduce_199,
+  1, 181, :_reduce_200,
+  1, 183, :_reduce_201,
+  1, 184, :_reduce_202,
+  2, 182, :_reduce_203,
+  1, 185, :_reduce_204,
+  1, 186, :_reduce_205,
+  2, 186, :_reduce_206,
+  2, 180, :_reduce_207,
+  2, 187, :_reduce_208,
+  2, 187, :_reduce_209,
+  3, 97, :_reduce_210,
+  0, 188, :_reduce_211,
+  2, 188, :_reduce_212,
+  4, 188, :_reduce_213,
+  1, 120, :_reduce_214,
+  3, 120, :_reduce_215,
+  5, 120, :_reduce_216,
+  1, 189, :_reduce_none,
+  1, 189, :_reduce_none,
+  1, 128, :_reduce_219,
+  1, 131, :_reduce_220,
+  1, 129, :_reduce_221,
+  1, 130, :_reduce_222,
+  1, 124, :_reduce_223,
+  1, 123, :_reduce_224,
+  1, 126, :_reduce_225,
   0, 133, :_reduce_none,
-  1, 133, :_reduce_219,
+  1, 133, :_reduce_227,
   0, 150, :_reduce_none,
   1, 150, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
   1, 158, :_reduce_none,
-  0, 98, :_reduce_236 ]
+  0, 98, :_reduce_244 ]
 
-racc_reduce_n = 237
+racc_reduce_n = 245
 
-racc_shift_n = 410
+racc_shift_n = 422
 
 racc_token_table = {
   false => 0,
   :error => 1,
   :STRING => 2,
   :DQPRE => 3,
   :DQMID => 4,
   :DQPOST => 5,
   :WORD => 6,
   :LBRACK => 7,
   :RBRACK => 8,
   :LBRACE => 9,
   :RBRACE => 10,
   :SYMBOL => 11,
   :FARROW => 12,
   :COMMA => 13,
   :TRUE => 14,
   :FALSE => 15,
   :EQUALS => 16,
   :APPENDS => 17,
   :DELETES => 18,
   :LESSEQUAL => 19,
   :NOTEQUAL => 20,
   :DOT => 21,
   :COLON => 22,
   :LLCOLLECT => 23,
   :RRCOLLECT => 24,
   :QMARK => 25,
   :LPAREN => 26,
   :RPAREN => 27,
   :ISEQUAL => 28,
   :GREATEREQUAL => 29,
   :GREATERTHAN => 30,
   :LESSTHAN => 31,
   :IF => 32,
   :ELSE => 33,
   :DEFINE => 34,
   :ELSIF => 35,
   :VARIABLE => 36,
   :CLASS => 37,
   :INHERITS => 38,
   :NODE => 39,
   :BOOLEAN => 40,
   :NAME => 41,
   :SEMIC => 42,
   :CASE => 43,
   :DEFAULT => 44,
   :AT => 45,
   :ATAT => 46,
   :LCOLLECT => 47,
   :RCOLLECT => 48,
   :CLASSREF => 49,
   :NOT => 50,
   :OR => 51,
   :AND => 52,
   :UNDEF => 53,
   :PARROW => 54,
   :PLUS => 55,
   :MINUS => 56,
   :TIMES => 57,
   :DIV => 58,
   :LSHIFT => 59,
   :RSHIFT => 60,
   :UMINUS => 61,
   :MATCH => 62,
   :NOMATCH => 63,
   :REGEX => 64,
   :IN_EDGE => 65,
   :OUT_EDGE => 66,
   :IN_EDGE_SUB => 67,
   :OUT_EDGE_SUB => 68,
   :IN => 69,
   :UNLESS => 70,
   :PIPE => 71,
   :LAMBDA => 72,
   :SELBRACE => 73,
   :NUMBER => 74,
   :HEREDOC => 75,
   :SUBLOCATE => 76,
   :RENDER_STRING => 77,
   :RENDER_EXPR => 78,
   :EPP_START => 79,
   :EPP_END => 80,
   :EPP_END_TRIM => 81,
   :FUNCTION => 82,
   :PRIVATE => 83,
   :ATTR => 84,
   :TYPE => 85,
   :LOW => 86,
   :HIGH => 87,
   :CALL => 88,
   :LISTSTART => 89,
   :SPLAT => 90,
   :MODULO => 91,
   :TITLE_COLON => 92,
   :CASE_COLON => 93 }
 
 racc_nt_base = 94
 
 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",
   "WORD",
   "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",
   "EPP_END",
   "EPP_END_TRIM",
   "FUNCTION",
   "PRIVATE",
   "ATTR",
   "TYPE",
   "LOW",
   "HIGH",
   "CALL",
   "LISTSTART",
   "SPLAT",
   "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",
   "reserved_word",
   "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",
   "name_or_number",
   "parameter",
+  "untyped_parameter",
+  "typed_parameter",
+  "regular_parameter",
+  "splat_parameter",
+  "parameter_type",
   "hashpairs",
   "hashpair",
   "string",
   "dq_string",
   "heredoc",
   "dqpre",
   "dqrval",
   "dqpost",
   "dqmid",
   "text_expression",
   "dqtail",
   "sublocated_text",
   "epp_parameters_list",
   "epp_end" ]
 
 Racc_debug_parser = false
 
 ##### State transition tables end #####
 
 # reduce 0 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 68)
   def _reduce_1(val, _values, result)
      result = create_program(Factory.block_or_expression(*val[0])) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 69)
   def _reduce_2(val, _values, result)
      result = create_program(Factory.block_or_expression(*val[0])) 
     result
   end
 .,.,
 
 # reduce 3 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 74)
   def _reduce_4(val, _values, result)
      result = transform_calls(val[0]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 80)
   def _reduce_5(val, _values, result)
      result = [val[0]]
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 81)
   def _reduce_6(val, _values, result)
      result = val[0].push val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 82)
   def _reduce_7(val, _values, result)
      result = val[0].push val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 86)
   def _reduce_8(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 87)
   def _reduce_9(val, _values, result)
      result = aryfy(val[0]).push val[2] 
     result
   end
 .,.,
 
 # reduce 10 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 93)
   def _reduce_11(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 94)
   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', 95)
   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', 96)
   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', 97)
   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', 104)
   def _reduce_17(val, _values, result)
      result = val[0][*val[2]]         ; loc result, val[0], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 105)
   def _reduce_18(val, _values, result)
      result = val[0].in val[2]        ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 106)
   def _reduce_19(val, _values, result)
      result = val[0] =~  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 107)
   def _reduce_20(val, _values, result)
      result = val[0].mne val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 108)
   def _reduce_21(val, _values, result)
      result = val[0] +   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 109)
   def _reduce_22(val, _values, result)
      result = val[0] -   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 110)
   def _reduce_23(val, _values, result)
      result = val[0] /   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 111)
   def _reduce_24(val, _values, result)
      result = val[0] *   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 112)
   def _reduce_25(val, _values, result)
      result = val[0] %   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 113)
   def _reduce_26(val, _values, result)
      result = val[0] <<  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 114)
   def _reduce_27(val, _values, result)
      result = val[0] >>  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 115)
   def _reduce_28(val, _values, result)
      result = val[1].minus()          ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 116)
   def _reduce_29(val, _values, result)
      result = val[1].unfold()         ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 117)
   def _reduce_30(val, _values, result)
      result = val[0].ne  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 118)
   def _reduce_31(val, _values, result)
      result = val[0] ==  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 119)
   def _reduce_32(val, _values, result)
      result = val[0] >   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 120)
   def _reduce_33(val, _values, result)
      result = val[0] >=  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 121)
   def _reduce_34(val, _values, result)
      result = val[0] <   val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 122)
   def _reduce_35(val, _values, result)
      result = val[0] <=  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 123)
   def _reduce_36(val, _values, result)
      result = val[1].not              ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 124)
   def _reduce_37(val, _values, result)
      result = val[0].and val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 125)
   def _reduce_38(val, _values, result)
      result = val[0].or  val[2]       ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 126)
   def _reduce_39(val, _values, result)
      result = val[0].set(val[2])      ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 127)
   def _reduce_40(val, _values, result)
      result = val[0].plus_set(val[2]) ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 128)
   def _reduce_41(val, _values, result)
      result = val[0].minus_set(val[2]); loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 129)
   def _reduce_42(val, _values, result)
      result = val[0].select(*val[2])  ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 130)
   def _reduce_43(val, _values, result)
      result = val[1].paren()          ; loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 138)
   def _reduce_44(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 139)
   def _reduce_45(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
 # 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
 
 # reduce 66 omitted
 
 # reduce 67 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 172)
   def _reduce_68(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 173)
   def _reduce_69(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 181)
   def _reduce_70(val, _values, result)
           result = Factory.CALL_NAMED(val[0], true, val[2])
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 185)
   def _reduce_71(val, _values, result)
           result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 189)
   def _reduce_72(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', 194)
   def _reduce_73(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', 198)
   def _reduce_74(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 203)
   def _reduce_75(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 204)
   def _reduce_76(val, _values, result)
      result = val[0]; val[0].lambda = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 207)
   def _reduce_77(val, _values, result)
      result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 208)
   def _reduce_78(val, _values, result)
      result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 209)
   def _reduce_79(val, _values, result)
      result = Factory.CALL_METHOD(val[0], []); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 214)
   def _reduce_80(val, _values, result)
             result = val[0].dot(Factory.fqn(val[2][:value]))
         loc result, val[1], val[2]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 226)
   def _reduce_81(val, _values, result)
           result = Factory.LAMBDA(val[0], val[1])
 #      loc result, val[1] # TODO
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 231)
   def _reduce_82(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 232)
   def _reduce_83(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 236)
   def _reduce_84(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 237)
   def _reduce_85(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 247)
   def _reduce_86(val, _values, result)
           result = val[1]
       loc(result, val[0], val[1])
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 254)
   def _reduce_87(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', 258)
   def _reduce_88(val, _values, result)
             result = Factory.IF(val[0], nil, val[3])
         loc(result, val[0], (val[3] ? val[3] : val[2]))
       
     result
   end
 .,.,
 
 # reduce 89 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 266)
   def _reduce_90(val, _values, result)
             result = val[1]
         loc(result, val[0], val[1])
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 270)
   def _reduce_91(val, _values, result)
             result = Factory.block_or_expression(*val[2])
         loc result, val[0], val[3]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 274)
   def _reduce_92(val, _values, result)
             result = nil # don't think a nop is needed here either
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 283)
   def _reduce_93(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', 287)
   def _reduce_94(val, _values, result)
           result = Factory.UNLESS(val[1], nil, nil)
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 # reduce 95 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 297)
   def _reduce_96(val, _values, result)
             result = Factory.block_or_expression(*val[2])
         loc result, val[0], val[3]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 301)
   def _reduce_97(val, _values, result)
             result = nil # don't think a nop is needed here either
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 309)
   def _reduce_98(val, _values, result)
           result = Factory.CASE(val[1], *val[3])
       loc result, val[0], val[4]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 315)
   def _reduce_99(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 316)
   def _reduce_100(val, _values, result)
      result = val[0].push val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 321)
   def _reduce_101(val, _values, result)
             result = Factory.WHEN(val[0], val[3])
         loc result, val[1], val[4]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 325)
   def _reduce_102(val, _values, result)
             result = Factory.WHEN(val[0], nil)
         loc result, val[1], val[3]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 329)
   def _reduce_103(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 # reduce 104 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 340)
   def _reduce_105(val, _values, result)
             result = val[1]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 345)
   def _reduce_106(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 346)
   def _reduce_107(val, _values, result)
      result = val[0].push val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 351)
   def _reduce_108(val, _values, result)
      result = Factory.MAP(val[0], val[2]) ; loc result, val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 363)
   def _reduce_109(val, _values, result)
           result = val[0]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 366)
   def _reduce_110(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', 381)
   def _reduce_111(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', 389)
   def _reduce_112(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', 402)
   def _reduce_113(val, _values, result)
           result = case Factory.resource_shape(val[0])
       when :resource, :class
         # This catches deprecated syntax.
         # If the attribute operations does not include +>, then the found expression
         # is actually a LEFT followed by LITERAL_HASH
         #
         unless tmp = transform_resource_wo_title(val[0], val[2])
           error val[1], "Syntax error resource body without title or hash with +>"
         end
         tmp
       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', 423)
   def _reduce_114(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', 428)
   def _reduce_115(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', 433)
   def _reduce_116(val, _values, result)
      result = Factory.RESOURCE_BODY(val[0], val[2]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 435)
   def _reduce_117(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 438)
   def _reduce_118(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 439)
   def _reduce_119(val, _values, result)
      result = val[0].push val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 444)
   def _reduce_120(val, _values, result)
      result = :virtual  
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 445)
   def _reduce_121(val, _values, result)
      result = :exported 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 446)
   def _reduce_122(val, _values, result)
      result = :exported 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 458)
   def _reduce_123(val, _values, result)
           result = Factory.COLLECT(val[0], val[1], val[3])
       loc result, val[0], val[5]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 462)
   def _reduce_124(val, _values, result)
           result = Factory.COLLECT(val[0], val[1], [])
       loc result, val[0], val[1]
     
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 467)
   def _reduce_125(val, _values, result)
      result = Factory.VIRTUAL_QUERY(val[1])   ; loc result, val[0], val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 468)
   def _reduce_126(val, _values, result)
      result = Factory.EXPORTED_QUERY(val[1])  ; loc result, val[0], val[2] 
     result
   end
 .,.,
 
 # reduce 127 omitted
 
 # reduce 128 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 481)
   def _reduce_129(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 482)
   def _reduce_130(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 483)
   def _reduce_131(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
 # reduce 132 omitted
 
 # reduce 133 omitted
 
 # reduce 134 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 499)
   def _reduce_135(val, _values, result)
             result = Factory.ATTRIBUTE_OP(val[0][:value], :'=>', val[2])
         loc result, val[0], val[2]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 503)
   def _reduce_136(val, _values, result)
             result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
         loc result, val[0], val[2]
       
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 513)
   def _reduce_137(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', 527)
   def _reduce_138(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', 537)
   def _reduce_139(val, _values, result)
      namestack(val[0][:value]) ; result = val[0] 
     result
   end
 .,.,
 
 # reduce 140 omitted
 
 # reduce 141 omitted
 
 # reduce 142 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 546)
   def _reduce_143(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 # reduce 144 omitted
 
 # reduce 145 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 563)
   def _reduce_146(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', 567)
   def _reduce_147(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', 577)
   def _reduce_148(val, _values, result)
      result = [result] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 578)
   def _reduce_149(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 583)
   def _reduce_150(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 584)
   def _reduce_151(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 585)
   def _reduce_152(val, _values, result)
      result = Factory.literal(:default); loc result, val[0] 
     result
   end
 .,.,
 
 # reduce 153 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 589)
   def _reduce_154(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 590)
   def _reduce_155(val, _values, result)
      result = Factory.concat(val[0], '.', val[2][:value]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
 # reduce 156 omitted
 
 # reduce 157 omitted
 
 # reduce 158 omitted
 
 module_eval(<<'.,.,', 'egrammar.ra', 599)
   def _reduce_159(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 615)
   def _reduce_160(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 616)
   def _reduce_161(val, _values, result)
      error val[0], "'class' is not a valid classname" 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 620)
   def _reduce_162(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 621)
   def _reduce_163(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 622)
   def _reduce_164(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 626)
   def _reduce_165(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 627)
   def _reduce_166(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 631)
-  def _reduce_167(val, _values, result)
+# reduce 167 omitted
+
+# reduce 168 omitted
+
+# reduce 169 omitted
+
+# reduce 170 omitted
+
+module_eval(<<'.,.,', 'egrammar.ra', 639)
+  def _reduce_171(val, _values, result)
      result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 632)
-  def _reduce_168(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 640)
+  def _reduce_172(val, _values, result)
      result = Factory.PARAM(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 645)
-  def _reduce_169(val, _values, result)
-     result = Factory.fqn(val[0][:value]).var ; loc result, val[0] 
+module_eval(<<'.,.,', 'egrammar.ra', 643)
+  def _reduce_173(val, _values, result)
+     result = val[1]; val[1].captures_rest() 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'egrammar.ra', 646)
+  def _reduce_174(val, _values, result)
+     val[1].type_expr(val[0]) ; result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'egrammar.ra', 649)
+  def _reduce_175(val, _values, result)
+     result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'egrammar.ra', 650)
-  def _reduce_170(val, _values, result)
+  def _reduce_176(val, _values, result)
+     result = val[0][*val[2]] ; loc result, val[0], val[3] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'egrammar.ra', 663)
+  def _reduce_177(val, _values, result)
+     result = Factory.fqn(val[0][:value]).var ; loc result, val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'egrammar.ra', 668)
+  def _reduce_178(val, _values, result)
      result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 651)
-  def _reduce_171(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 669)
+  def _reduce_179(val, _values, result)
      result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 652)
-  def _reduce_172(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 670)
+  def _reduce_180(val, _values, result)
      result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 653)
-  def _reduce_173(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 671)
+  def _reduce_181(val, _values, result)
      result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 659)
-  def _reduce_174(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 677)
+  def _reduce_182(val, _values, result)
      result = Factory.LIST(val[1]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 660)
-  def _reduce_175(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 678)
+  def _reduce_183(val, _values, result)
      result = Factory.LIST(val[1]); loc result, val[0], val[3] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 661)
-  def _reduce_176(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 679)
+  def _reduce_184(val, _values, result)
      result = Factory.literal([]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 662)
-  def _reduce_177(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 680)
+  def _reduce_185(val, _values, result)
      result = Factory.LIST(val[1]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 663)
-  def _reduce_178(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 681)
+  def _reduce_186(val, _values, result)
      result = Factory.LIST(val[1]); loc result, val[0], val[3] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 664)
-  def _reduce_179(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 682)
+  def _reduce_187(val, _values, result)
      result = Factory.literal([]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 667)
-  def _reduce_180(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 685)
+  def _reduce_188(val, _values, result)
      result = Factory.HASH(val[1]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 668)
-  def _reduce_181(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 686)
+  def _reduce_189(val, _values, result)
      result = Factory.HASH(val[1]); loc result, val[0], val[3] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 669)
-  def _reduce_182(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 687)
+  def _reduce_190(val, _values, result)
      result = Factory.literal({}) ; loc result, val[0], val[3] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 672)
-  def _reduce_183(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 690)
+  def _reduce_191(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 673)
-  def _reduce_184(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 691)
+  def _reduce_192(val, _values, result)
      result = val[0].push val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 676)
-  def _reduce_185(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 694)
+  def _reduce_193(val, _values, result)
      result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] 
     result
   end
 .,.,
 
-# reduce 186 omitted
+# reduce 194 omitted
 
-# reduce 187 omitted
+# reduce 195 omitted
 
-# reduce 188 omitted
+# reduce 196 omitted
 
-module_eval(<<'.,.,', 'egrammar.ra', 684)
-  def _reduce_189(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 702)
+  def _reduce_197(val, _values, result)
      result = Factory.literal(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 685)
-  def _reduce_190(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 703)
+  def _reduce_198(val, _values, result)
      result = Factory.literal(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 687)
-  def _reduce_191(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 705)
+  def _reduce_199(val, _values, result)
      result = Factory.string(val[0], *val[1]) ; loc result, val[0], val[1][-1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 688)
-  def _reduce_192(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 706)
+  def _reduce_200(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 689)
-  def _reduce_193(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 707)
+  def _reduce_201(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 690)
-  def _reduce_194(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 708)
+  def _reduce_202(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 691)
-  def _reduce_195(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 709)
+  def _reduce_203(val, _values, result)
      result = [val[0]] + val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 692)
-  def _reduce_196(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 710)
+  def _reduce_204(val, _values, result)
      result = Factory.TEXT(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 695)
-  def _reduce_197(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 713)
+  def _reduce_205(val, _values, result)
      result = [val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 696)
-  def _reduce_198(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 714)
+  def _reduce_206(val, _values, result)
      result = [val[0]] + val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 699)
-  def _reduce_199(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 717)
+  def _reduce_207(val, _values, result)
      result = Factory.HEREDOC(val[0][:value], val[1]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 702)
-  def _reduce_200(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 720)
+  def _reduce_208(val, _values, result)
      result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 703)
-  def _reduce_201(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 721)
+  def _reduce_209(val, _values, result)
      result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 706)
-  def _reduce_202(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 724)
+  def _reduce_210(val, _values, result)
      result = Factory.EPP(val[1], val[2]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 709)
-  def _reduce_203(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 727)
+  def _reduce_211(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 710)
-  def _reduce_204(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 728)
+  def _reduce_212(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 711)
-  def _reduce_205(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 729)
+  def _reduce_213(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 714)
-  def _reduce_206(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 732)
+  def _reduce_214(val, _values, result)
      result = Factory.RENDER_STRING(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 715)
-  def _reduce_207(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 733)
+  def _reduce_215(val, _values, result)
      result = Factory.RENDER_EXPR(val[1]); loc result, val[0], val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 716)
-  def _reduce_208(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 734)
+  def _reduce_216(val, _values, result)
      result = Factory.RENDER_EXPR(Factory.block_or_expression(*val[2])); loc result, val[0], val[4] 
     result
   end
 .,.,
 
-# reduce 209 omitted
+# reduce 217 omitted
 
-# reduce 210 omitted
+# reduce 218 omitted
 
-module_eval(<<'.,.,', 'egrammar.ra', 722)
-  def _reduce_211(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 740)
+  def _reduce_219(val, _values, result)
      result = Factory.NUMBER(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 723)
-  def _reduce_212(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 741)
+  def _reduce_220(val, _values, result)
      result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 724)
-  def _reduce_213(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 742)
+  def _reduce_221(val, _values, result)
      result = Factory.QREF(val[0][:value])  ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 725)
-  def _reduce_214(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 743)
+  def _reduce_222(val, _values, result)
      result = Factory.literal(:undef); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 726)
-  def _reduce_215(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 744)
+  def _reduce_223(val, _values, result)
      result = Factory.literal(:default); loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 731)
-  def _reduce_216(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 749)
+  def _reduce_224(val, _values, result)
      result = Factory.literal(val[0][:value]) ; loc result, val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'egrammar.ra', 734)
-  def _reduce_217(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 752)
+  def _reduce_225(val, _values, result)
      result = Factory.literal(val[0][:value]); loc result, val[0] 
     result
   end
 .,.,
 
-# reduce 218 omitted
+# reduce 226 omitted
 
-module_eval(<<'.,.,', 'egrammar.ra', 740)
-  def _reduce_219(val, _values, result)
+module_eval(<<'.,.,', 'egrammar.ra', 758)
+  def _reduce_227(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-# reduce 220 omitted
-
-# reduce 221 omitted
-
-# reduce 222 omitted
-
-# reduce 223 omitted
-
-# reduce 224 omitted
-
-# reduce 225 omitted
-
-# reduce 226 omitted
-
-# reduce 227 omitted
-
 # reduce 228 omitted
 
 # reduce 229 omitted
 
 # reduce 230 omitted
 
 # reduce 231 omitted
 
 # reduce 232 omitted
 
 # reduce 233 omitted
 
 # reduce 234 omitted
 
 # reduce 235 omitted
 
-module_eval(<<'.,.,', 'egrammar.ra', 763)
-  def _reduce_236(val, _values, result)
+# reduce 236 omitted
+
+# reduce 237 omitted
+
+# reduce 238 omitted
+
+# reduce 239 omitted
+
+# reduce 240 omitted
+
+# reduce 241 omitted
+
+# reduce 242 omitted
+
+# reduce 243 omitted
+
+module_eval(<<'.,.,', 'egrammar.ra', 781)
+  def _reduce_244(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