module Treetop
  module Compiler
    module Metagrammar
      include Treetop::Runtime
      
      def root
        @root || :treetop_file
      end
      
      module TreetopFile0
        def prefix
          elements[0]
        end
        
        def module_or_grammar
          elements[1]
        end
        
        def suffix
          elements[2]
        end
      end
      
      module TreetopFile1
        def compile
          prefix.text_value + module_or_grammar.compile + suffix.text_value
        end
      end
      
      def _nt_treetop_file
        start_index = index
        cached = node_cache[:treetop_file][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        r2 = _nt_space
        if r2
          r1 = r2
        else
          r1 = SyntaxNode.new(input, index...index)
        end
        s0 << r1
        if r1
          i3 = index
          r4 = _nt_module_declaration
          if r4
            r3 = r4
          else
            r5 = _nt_grammar
            if r5
              r3 = r5
            else
              self.index = i3
              r3 = nil
            end
          end
          s0 << r3
          if r3
            r7 = _nt_space
            if r7
              r6 = r7
            else
              r6 = SyntaxNode.new(input, index...index)
            end
            s0 << r6
          end
        end
        if s0.last
          r0 = (SyntaxNode).new(input, i0...index, s0)
          r0.extend(TreetopFile0)
          r0.extend(TreetopFile1)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:treetop_file][start_index] = r0
        
        return r0
      end
      
      module ModuleDeclaration0
        def space
          elements[1]
        end
        
        def space
          elements[4]
        end
      end
      
      module ModuleDeclaration1
        def space
          elements[0]
        end
        
      end
      
      module ModuleDeclaration2
        def prefix
          elements[0]
        end
        
        def module_contents
          elements[1]
        end
        
        def suffix
          elements[2]
        end
      end
      
      module ModuleDeclaration3
        def compile
          prefix.text_value + module_contents.compile + suffix.text_value
        end
      end
      
      def _nt_module_declaration
        start_index = index
        cached = node_cache[:module_declaration][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        i1, s1 = index, []
        if input.index('module', index) == index
          r2 = (SyntaxNode).new(input, index...(index + 6))
          @index += 6
        else
          terminal_parse_failure('module')
          r2 = nil
        end
        s1 << r2
        if r2
          r3 = _nt_space
          s1 << r3
          if r3
            if input.index(/[A-Z]/, index) == index
              r4 = (SyntaxNode).new(input, index...(index + 1))
              @index += 1
            else
              r4 = nil
            end
            s1 << r4
            if r4
              s5, i5 = [], index
              loop do
                r6 = _nt_alphanumeric_char
                if r6
                  s5 << r6
                else
                  break
                end
              end
              r5 = SyntaxNode.new(input, i5...index, s5)
              s1 << r5
              if r5
                r7 = _nt_space
                s1 << r7
              end
            end
          end
        end
        if s1.last
          r1 = (SyntaxNode).new(input, i1...index, s1)
          r1.extend(ModuleDeclaration0)
        else
          self.index = i1
          r1 = nil
        end
        s0 << r1
        if r1
          i8 = index
          r9 = _nt_module_declaration
          if r9
            r8 = r9
          else
            r10 = _nt_grammar
            if r10
              r8 = r10
            else
              self.index = i8
              r8 = nil
            end
          end
          s0 << r8
          if r8
            i11, s11 = index, []
            r12 = _nt_space
            s11 << r12
            if r12
              if input.index('end', index) == index
                r13 = (SyntaxNode).new(input, index...(index + 3))
                @index += 3
              else
                terminal_parse_failure('end')
                r13 = nil
              end
              s11 << r13
            end
            if s11.last
              r11 = (SyntaxNode).new(input, i11...index, s11)
              r11.extend(ModuleDeclaration1)
            else
              self.index = i11
              r11 = nil
            end
            s0 << r11
          end
        end
        if s0.last
          r0 = (SyntaxNode).new(input, i0...index, s0)
          r0.extend(ModuleDeclaration2)
          r0.extend(ModuleDeclaration3)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:module_declaration][start_index] = r0
        
        return r0
      end
      
      module Grammar0
        def space
          elements[1]
        end
        
        def grammar_name
          elements[2]
        end
        
        def space
          elements[3]
        end
        
        def declaration_sequence
          elements[4]
        end
        
      end
      
      def _nt_grammar
        start_index = index
        cached = node_cache[:grammar][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        if input.index('grammar', index) == index
          r1 = (SyntaxNode).new(input, index...(index + 7))
          @index += 7
        else
          terminal_parse_failure('grammar')
          r1 = nil
        end
        s0 << r1
        if r1
          r2 = _nt_space
          s0 << r2
          if r2
            r3 = _nt_grammar_name
            s0 << r3
            if r3
              r4 = _nt_space
              s0 << r4
              if r4
                r5 = _nt_declaration_sequence
                s0 << r5
                if r5
                  r7 = _nt_space
                  if r7
                    r6 = r7
                  else
                    r6 = SyntaxNode.new(input, index...index)
                  end
                  s0 << r6
                  if r6
                    if input.index('end', index) == index
                      r8 = (SyntaxNode).new(input, index...(index + 3))
                      @index += 3
                    else
                      terminal_parse_failure('end')
                      r8 = nil
                    end
                    s0 << r8
                  end
                end
              end
            end
          end
        end
        if s0.last
          r0 = (Grammar).new(input, i0...index, s0)
          r0.extend(Grammar0)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:grammar][start_index] = r0
        
        return r0
      end
      
      module GrammarName0
      end
      
      def _nt_grammar_name
        start_index = index
        cached = node_cache[:grammar_name][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        if input.index(/[A-Z]/, index) == index
          r1 = (SyntaxNode).new(input, index...(index + 1))
          @index += 1
        else
          r1 = nil
        end
        s0 << r1
        if r1
          s2, i2 = [], index
          loop do
            r3 = _nt_alphanumeric_char
            if r3
              s2 << r3
            else
              break
            end
          end
          r2 = SyntaxNode.new(input, i2...index, s2)
          s0 << r2
        end
        if s0.last
          r0 = (SyntaxNode).new(input, i0...index, s0)
          r0.extend(GrammarName0)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:grammar_name][start_index] = r0
        
        return r0
      end
      
      module DeclarationSequence0
        def space
          elements[0]
        end
        
        def declaration
          elements[1]
        end
      end
      
      module DeclarationSequence1
        def head
          elements[0]
        end
        
        def tail
          elements[1]
        end
      end
      
      module DeclarationSequence2
        def declarations
          [head] + tail
        end
    
        def tail
          super.elements.map { |elt| elt.declaration }
        end
      end
      
      module DeclarationSequence3
        def compile(builder)
        end
      end
      
      def _nt_declaration_sequence
        start_index = index
        cached = node_cache[:declaration_sequence][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        i1, s1 = index, []
        r2 = _nt_declaration
        s1 << r2
        if r2
          s3, i3 = [], index
          loop do
            i4, s4 = index, []
            r5 = _nt_space
            s4 << r5
            if r5
              r6 = _nt_declaration
              s4 << r6
            end
            if s4.last
              r4 = (SyntaxNode).new(input, i4...index, s4)
              r4.extend(DeclarationSequence0)
            else
              self.index = i4
              r4 = nil
            end
            if r4
              s3 << r4
            else
              break
            end
          end
          r3 = SyntaxNode.new(input, i3...index, s3)
          s1 << r3
        end
        if s1.last
          r1 = (DeclarationSequence).new(input, i1...index, s1)
          r1.extend(DeclarationSequence1)
          r1.extend(DeclarationSequence2)
        else
          self.index = i1
          r1 = nil
        end
        if r1
          r0 = r1
        else
          if input.index('', index) == index
            r7 = (SyntaxNode).new(input, index...(index + 0))
            r7.extend(DeclarationSequence3)
            @index += 0
          else
            terminal_parse_failure('')
            r7 = nil
          end
          if r7
            r0 = r7
          else
            self.index = i0
            r0 = nil
          end
        end
        
        node_cache[:declaration_sequence][start_index] = r0
        
        return r0
      end
      
      def _nt_declaration
        start_index = index
        cached = node_cache[:declaration][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        r1 = _nt_parsing_rule
        if r1
          r0 = r1
        else
          r2 = _nt_include_declaration
          if r2
            r0 = r2
          else
            self.index = i0
            r0 = nil
          end
        end
        
        node_cache[:declaration][start_index] = r0
        
        return r0
      end
      
      module IncludeDeclaration0
        def space
          elements[1]
        end
        
      end
      
      module IncludeDeclaration1
        def compile(builder)
          builder << text_value
        end
      end
      
      def _nt_include_declaration
        start_index = index
        cached = node_cache[:include_declaration][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        if input.index('include', index) == index
          r1 = (SyntaxNode).new(input, index...(index + 7))
          @index += 7
        else
          terminal_parse_failure('include')
          r1 = nil
        end
        s0 << r1
        if r1
          r2 = _nt_space
          s0 << r2
          if r2
            if input.index(/[A-Z]/, index) == index
              r3 = (SyntaxNode).new(input, index...(index + 1))
              @index += 1
            else
              r3 = nil
            end
            s0 << r3
            if r3
              s4, i4 = [], index
              loop do
                i5 = index
                r6 = _nt_alphanumeric_char
                if r6
                  r5 = r6
                else
                  if input.index('::', index) == index
                    r7 = (SyntaxNode).new(input, index...(index + 2))
                    @index += 2
                  else
                    terminal_parse_failure('::')
                    r7 = nil
                  end
                  if r7
                    r5 = r7
                  else
                    self.index = i5
                    r5 = nil
                  end
                end
                if r5
                  s4 << r5
                else
                  break
                end
              end
              r4 = SyntaxNode.new(input, i4...index, s4)
              s0 << r4
            end
          end
        end
        if s0.last
          r0 = (SyntaxNode).new(input, i0...index, s0)
          r0.extend(IncludeDeclaration0)
          r0.extend(IncludeDeclaration1)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:include_declaration][start_index] = r0
        
        return r0
      end
      
      module ParsingRule0
        def space
          elements[1]
        end
        
        def nonterminal
          elements[2]
        end
        
        def space
          elements[3]
        end
        
        def parsing_expression
          elements[4]
        end
        
        def space
          elements[5]
        end
        
      end
      
      def _nt_parsing_rule
        start_index = index
        cached = node_cache[:parsing_rule][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        if input.index('rule', index) == index
          r1 = (SyntaxNode).new(input, index...(index + 4))
          @index += 4
        else
          terminal_parse_failure('rule')
          r1 = nil
        end
        s0 << r1
        if r1
          r2 = _nt_space
          s0 << r2
          if r2
            r3 = _nt_nonterminal
            s0 << r3
            if r3
              r4 = _nt_space
              s0 << r4
              if r4
                r5 = _nt_parsing_expression
                s0 << r5
                if r5
                  r6 = _nt_space
                  s0 << r6
                  if r6
                    if input.index('end', index) == index
                      r7 = (SyntaxNode).new(input, index...(index + 3))
                      @index += 3
                    else
                      terminal_parse_failure('end')
                      r7 = nil
                    end
                    s0 << r7
                  end
                end
              end
            end
          end
        end
        if s0.last
          r0 = (ParsingRule).new(input, i0...index, s0)
          r0.extend(ParsingRule0)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:parsing_rule][start_index] = r0
        
        return r0
      end
      
      def _nt_parsing_expression
        start_index = index
        cached = node_cache[:parsing_expression][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        r1 = _nt_choice
        if r1
          r0 = r1
        else
          r2 = _nt_sequence
          if r2
            r0 = r2
          else
            r3 = _nt_primary
            if r3
              r0 = r3
            else
              self.index = i0
              r0 = nil
            end
          end
        end
        
        node_cache[:parsing_expression][start_index] = r0
        
        return r0
      end
      
      module Choice0
        def alternative
          elements[3]
        end
      end
      
      module Choice1
        def head
          elements[0]
        end
        
        def tail
          elements[1]
        end
      end
      
      module Choice2
        def alternatives
          [head] + tail
        end
        
        def tail
          super.elements.map {|elt| elt.alternative}
        end
        
        def inline_modules
          (alternatives.map {|alt| alt.inline_modules }).flatten
        end
      end
      
      def _nt_choice
        start_index = index
        cached = node_cache[:choice][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        r1 = _nt_alternative
        s0 << r1
        if r1
          s2, i2 = [], index
          loop do
            i3, s3 = index, []
            r5 = _nt_space
            if r5
              r4 = r5
            else
              r4 = SyntaxNode.new(input, index...index)
            end
            s3 << r4
            if r4
              if input.index('/', index) == index
                r6 = (SyntaxNode).new(input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure('/')
                r6 = nil
              end
              s3 << r6
              if r6
                r8 = _nt_space
                if r8
                  r7 = r8
                else
                  r7 = SyntaxNode.new(input, index...index)
                end
                s3 << r7
                if r7
                  r9 = _nt_alternative
                  s3 << r9
                end
              end
            end
            if s3.last
              r3 = (SyntaxNode).new(input, i3...index, s3)
              r3.extend(Choice0)
            else
              self.index = i3
              r3 = nil
            end
            if r3
              s2 << r3
            else
              break
            end
          end
          if s2.empty?
            self.index = i2
            r2 = nil
          else
            r2 = SyntaxNode.new(input, i2...index, s2)
          end
          s0 << r2
        end
        if s0.last
          r0 = (Choice).new(input, i0...index, s0)
          r0.extend(Choice1)
          r0.extend(Choice2)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:choice][start_index] = r0
        
        return r0
      end
      
      module Sequence0
        def space
          elements[0]
        end
        
        def labeled_sequence_primary
          elements[1]
        end
      end
      
      module Sequence1
        def head
          elements[0]
        end
        
        def tail
          elements[1]
        end
        
        def node_class_declarations
          elements[2]
        end
      end
      
      module Sequence2
        def sequence_elements
          [head] + tail
        end
  
        def tail
          super.elements.map {|elt| elt.labeled_sequence_primary }
        end
    
        def inline_modules
          (sequence_elements.map {|elt| elt.inline_modules}).flatten +
          [sequence_element_accessor_module] +
          node_class_declarations.inline_modules
        end
    
        def inline_module_name
          node_class_declarations.inline_module_name
        end
      end
      
      def _nt_sequence
        start_index = index
        cached = node_cache[:sequence][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        r1 = _nt_labeled_sequence_primary
        s0 << r1
        if r1
          s2, i2 = [], index
          loop do
            i3, s3 = index, []
            r4 = _nt_space
            s3 << r4
            if r4
              r5 = _nt_labeled_sequence_primary
              s3 << r5
            end
            if s3.last
              r3 = (SyntaxNode).new(input, i3...index, s3)
              r3.extend(Sequence0)
            else
              self.index = i3
              r3 = nil
            end
            if r3
              s2 << r3
            else
              break
            end
          end
          if s2.empty?
            self.index = i2
            r2 = nil
          else
            r2 = SyntaxNode.new(input, i2...index, s2)
          end
          s0 << r2
          if r2
            r6 = _nt_node_class_declarations
            s0 << r6
          end
        end
        if s0.last
          r0 = (Sequence).new(input, i0...index, s0)
          r0.extend(Sequence1)
          r0.extend(Sequence2)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:sequence][start_index] = r0
        
        return r0
      end
      
      def _nt_alternative
        start_index = index
        cached = node_cache[:alternative][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        r1 = _nt_sequence
        if r1
          r0 = r1
        else
          r2 = _nt_primary
          if r2
            r0 = r2
          else
            self.index = i0
            r0 = nil
          end
        end
        
        node_cache[:alternative][start_index] = r0
        
        return r0
      end
      
      module Primary0
        def prefix
          elements[0]
        end
        
        def atomic
          elements[1]
        end
      end
      
      module Primary1
        def compile(address, builder, parent_expression=nil)
          prefix.compile(address, builder, self)
        end
    
        def predicated_expression
          atomic
        end
    
        def inline_modules
          atomic.inline_modules
        end
    
        def inline_module_name
          nil
        end
      end
      
      module Primary2
        def atomic
          elements[0]
        end
        
        def suffix
          elements[1]
        end
        
        def node_class_declarations
          elements[2]
        end
      end
      
      module Primary3
        def compile(address, builder, parent_expression=nil)
          suffix.compile(address, builder, self)
        end
    
        def optional_expression
          atomic
        end
    
        def node_class_name
          node_class_declarations.node_class_name
        end
    
        def inline_modules
          atomic.inline_modules + node_class_declarations.inline_modules
        end
    
        def inline_module_name
          node_class_declarations.inline_module_name
        end
      end
      
      module Primary4
        def atomic
          elements[0]
        end
        
        def node_class_declarations
          elements[1]
        end
      end
      
      module Primary5
        def compile(address, builder, parent_expression=nil)
          atomic.compile(address, builder, self)
        end
    
        def node_class_name
          node_class_declarations.node_class_name
        end
    
        def inline_modules
          atomic.inline_modules + node_class_declarations.inline_modules
        end
    
        def inline_module_name
          node_class_declarations.inline_module_name
        end
      end
      
      def _nt_primary
        start_index = index
        cached = node_cache[:primary][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        i1, s1 = index, []
        r2 = _nt_prefix
        s1 << r2
        if r2
          r3 = _nt_atomic
          s1 << r3
        end
        if s1.last
          r1 = (SyntaxNode).new(input, i1...index, s1)
          r1.extend(Primary0)
          r1.extend(Primary1)
        else
          self.index = i1
          r1 = nil
        end
        if r1
          r0 = r1
        else
          i4, s4 = index, []
          r5 = _nt_atomic
          s4 << r5
          if r5
            r6 = _nt_suffix
            s4 << r6
            if r6
              r7 = _nt_node_class_declarations
              s4 << r7
            end
          end
          if s4.last
            r4 = (SyntaxNode).new(input, i4...index, s4)
            r4.extend(Primary2)
            r4.extend(Primary3)
          else
            self.index = i4
            r4 = nil
          end
          if r4
            r0 = r4
          else
            i8, s8 = index, []
            r9 = _nt_atomic
            s8 << r9
            if r9
              r10 = _nt_node_class_declarations
              s8 << r10
            end
            if s8.last
              r8 = (SyntaxNode).new(input, i8...index, s8)
              r8.extend(Primary4)
              r8.extend(Primary5)
            else
              self.index = i8
              r8 = nil
            end
            if r8
              r0 = r8
            else
              self.index = i0
              r0 = nil
            end
          end
        end
        
        node_cache[:primary][start_index] = r0
        
        return r0
      end
      
      module LabeledSequencePrimary0
        def label
          elements[0]
        end
        
        def sequence_primary
          elements[1]
        end
      end
      
      module LabeledSequencePrimary1
        def compile(lexical_address, builder)
          sequence_primary.compile(lexical_address, builder)
        end
    
        def inline_modules
          sequence_primary.inline_modules
        end
    
        def label_name
          if label.name
            label.name
          elsif sequence_primary.instance_of?(Nonterminal)
            sequence_primary.text_value
          else
            nil
          end
        end
      end
      
      def _nt_labeled_sequence_primary
        start_index = index
        cached = node_cache[:labeled_sequence_primary][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        r1 = _nt_label
        s0 << r1
        if r1
          r2 = _nt_sequence_primary
          s0 << r2
        end
        if s0.last
          r0 = (SyntaxNode).new(input, i0...index, s0)
          r0.extend(LabeledSequencePrimary0)
          r0.extend(LabeledSequencePrimary1)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:labeled_sequence_primary][start_index] = r0
        
        return r0
      end
      
      module Label0
        def alpha_char
          elements[0]
        end
        
      end
      
      module Label1
      end
      
      module Label2
        def name
          elements[0].text_value
        end
      end
      
      module Label3
        def name
          nil
        end
      end
      
      def _nt_label
        start_index = index
        cached = node_cache[:label][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        i1, s1 = index, []
        i2, s2 = index, []
        r3 = _nt_alpha_char
        s2 << r3
        if r3
          s4, i4 = [], index
          loop do
            r5 = _nt_alphanumeric_char
            if r5
              s4 << r5
            else
              break
            end
          end
          r4 = SyntaxNode.new(input, i4...index, s4)
          s2 << r4
        end
        if s2.last
          r2 = (SyntaxNode).new(input, i2...index, s2)
          r2.extend(Label0)
        else
          self.index = i2
          r2 = nil
        end
        s1 << r2
        if r2
          if input.index(':', index) == index
            r6 = (SyntaxNode).new(input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(':')
            r6 = nil
          end
          s1 << r6
        end
        if s1.last
          r1 = (SyntaxNode).new(input, i1...index, s1)
          r1.extend(Label1)
          r1.extend(Label2)
        else
          self.index = i1
          r1 = nil
        end
        if r1
          r0 = r1
        else
          if input.index('', index) == index
            r7 = (SyntaxNode).new(input, index...(index + 0))
            r7.extend(Label3)
            @index += 0
          else
            terminal_parse_failure('')
            r7 = nil
          end
          if r7
            r0 = r7
          else
            self.index = i0
            r0 = nil
          end
        end
        
        node_cache[:label][start_index] = r0
        
        return r0
      end
      
      module SequencePrimary0
        def prefix
          elements[0]
        end
        
        def atomic
          elements[1]
        end
      end
      
      module SequencePrimary1
        def compile(lexical_address, builder)
          prefix.compile(lexical_address, builder, self)
        end
    
        def predicated_expression
          elements[1]
        end
    
        def inline_modules
          atomic.inline_modules
        end
    
        def inline_module_name
          nil
        end
      end
      
      module SequencePrimary2
        def atomic
          elements[0]
        end
        
        def suffix
          elements[1]
        end
      end
      
      module SequencePrimary3
        def compile(lexical_address, builder)
          suffix.compile(lexical_address, builder, self)
        end
    
        def node_class_name
          nil
        end
    
        def inline_modules
          atomic.inline_modules
        end
    
        def inline_module_name
          nil
        end
      end
      
      def _nt_sequence_primary
        start_index = index
        cached = node_cache[:sequence_primary][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        i1, s1 = index, []
        r2 = _nt_prefix
        s1 << r2
        if r2
          r3 = _nt_atomic
          s1 << r3
        end
        if s1.last
          r1 = (SyntaxNode).new(input, i1...index, s1)
          r1.extend(SequencePrimary0)
          r1.extend(SequencePrimary1)
        else
          self.index = i1
          r1 = nil
        end
        if r1
          r0 = r1
        else
          i4, s4 = index, []
          r5 = _nt_atomic
          s4 << r5
          if r5
            r6 = _nt_suffix
            s4 << r6
          end
          if s4.last
            r4 = (SyntaxNode).new(input, i4...index, s4)
            r4.extend(SequencePrimary2)
            r4.extend(SequencePrimary3)
          else
            self.index = i4
            r4 = nil
          end
          if r4
            r0 = r4
          else
            r7 = _nt_atomic
            if r7
              r0 = r7
            else
              self.index = i0
              r0 = nil
            end
          end
        end
        
        node_cache[:sequence_primary][start_index] = r0
        
        return r0
      end
      
      def _nt_suffix
        start_index = index
        cached = node_cache[:suffix][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        r1 = _nt_repetition_suffix
        if r1
          r0 = r1
        else
          r2 = _nt_optional_suffix
          if r2
            r0 = r2
          else
            self.index = i0
            r0 = nil
          end
        end
        
        node_cache[:suffix][start_index] = r0
        
        return r0
      end
      
      def _nt_optional_suffix
        start_index = index
        cached = node_cache[:optional_suffix][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        if input.index('?', index) == index
          r0 = (Optional).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('?')
          r0 = nil
        end
        
        node_cache[:optional_suffix][start_index] = r0
        
        return r0
      end
      
      module NodeClassDeclarations0
        def node_class_expression
          elements[0]
        end
        
        def trailing_inline_module
          elements[1]
        end
      end
      
      module NodeClassDeclarations1
        def node_class_name
          node_class_expression.node_class_name
        end
    
        def inline_modules
          trailing_inline_module.inline_modules
        end
    
        def inline_module
          trailing_inline_module.inline_module
        end
    
        def inline_module_name
          inline_module.module_name if inline_module
        end
      end
      
      def _nt_node_class_declarations
        start_index = index
        cached = node_cache[:node_class_declarations][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        r1 = _nt_node_class_expression
        s0 << r1
        if r1
          r2 = _nt_trailing_inline_module
          s0 << r2
        end
        if s0.last
          r0 = (SyntaxNode).new(input, i0...index, s0)
          r0.extend(NodeClassDeclarations0)
          r0.extend(NodeClassDeclarations1)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:node_class_declarations][start_index] = r0
        
        return r0
      end
      
      def _nt_repetition_suffix
        start_index = index
        cached = node_cache[:repetition_suffix][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        if input.index('+', index) == index
          r1 = (OneOrMore).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('+')
          r1 = nil
        end
        if r1
          r0 = r1
        else
          if input.index('*', index) == index
            r2 = (ZeroOrMore).new(input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure('*')
            r2 = nil
          end
          if r2
            r0 = r2
          else
            self.index = i0
            r0 = nil
          end
        end
        
        node_cache[:repetition_suffix][start_index] = r0
        
        return r0
      end
      
      def _nt_prefix
        start_index = index
        cached = node_cache[:prefix][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        if input.index('&', index) == index
          r1 = (AndPredicate).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('&')
          r1 = nil
        end
        if r1
          r0 = r1
        else
          if input.index('!', index) == index
            r2 = (NotPredicate).new(input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure('!')
            r2 = nil
          end
          if r2
            r0 = r2
          else
            self.index = i0
            r0 = nil
          end
        end
        
        node_cache[:prefix][start_index] = r0
        
        return r0
      end
      
      def _nt_atomic
        start_index = index
        cached = node_cache[:atomic][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        r1 = _nt_terminal
        if r1
          r0 = r1
        else
          r2 = _nt_nonterminal
          if r2
            r0 = r2
          else
            r3 = _nt_parenthesized_expression
            if r3
              r0 = r3
            else
              self.index = i0
              r0 = nil
            end
          end
        end
        
        node_cache[:atomic][start_index] = r0
        
        return r0
      end
      
      module ParenthesizedExpression0
        def parsing_expression
          elements[2]
        end
        
      end
      
      module ParenthesizedExpression1
        def inline_modules
          parsing_expression.inline_modules
        end
      end
      
      def _nt_parenthesized_expression
        start_index = index
        cached = node_cache[:parenthesized_expression][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        if input.index('(', index) == index
          r1 = (SyntaxNode).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('(')
          r1 = nil
        end
        s0 << r1
        if r1
          r3 = _nt_space
          if r3
            r2 = r3
          else
            r2 = SyntaxNode.new(input, index...index)
          end
          s0 << r2
          if r2
            r4 = _nt_parsing_expression
            s0 << r4
            if r4
              r6 = _nt_space
              if r6
                r5 = r6
              else
                r5 = SyntaxNode.new(input, index...index)
              end
              s0 << r5
              if r5
                if input.index(')', index) == index
                  r7 = (SyntaxNode).new(input, index...(index + 1))
                  @index += 1
                else
                  terminal_parse_failure(')')
                  r7 = nil
                end
                s0 << r7
              end
            end
          end
        end
        if s0.last
          r0 = (ParenthesizedExpression).new(input, i0...index, s0)
          r0.extend(ParenthesizedExpression0)
          r0.extend(ParenthesizedExpression1)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:parenthesized_expression][start_index] = r0
        
        return r0
      end
      
      module Nonterminal0
        def alpha_char
          elements[0]
        end
        
      end
      
      module Nonterminal1
      end
      
      def _nt_nonterminal
        start_index = index
        cached = node_cache[:nonterminal][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        i1 = index
        r2 = _nt_keyword_inside_grammar
        if r2
          r1 = nil
        else
          self.index = i1
          r1 = SyntaxNode.new(input, index...index)
        end
        s0 << r1
        if r1
          i3, s3 = index, []
          r4 = _nt_alpha_char
          s3 << r4
          if r4
            s5, i5 = [], index
            loop do
              r6 = _nt_alphanumeric_char
              if r6
                s5 << r6
              else
                break
              end
            end
            r5 = SyntaxNode.new(input, i5...index, s5)
            s3 << r5
          end
          if s3.last
            r3 = (SyntaxNode).new(input, i3...index, s3)
            r3.extend(Nonterminal0)
          else
            self.index = i3
            r3 = nil
          end
          s0 << r3
        end
        if s0.last
          r0 = (Nonterminal).new(input, i0...index, s0)
          r0.extend(Nonterminal1)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:nonterminal][start_index] = r0
        
        return r0
      end
      
      def _nt_terminal
        start_index = index
        cached = node_cache[:terminal][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        r1 = _nt_quoted_string
        if r1
          r0 = r1
        else
          r2 = _nt_character_class
          if r2
            r0 = r2
          else
            r3 = _nt_anything_symbol
            if r3
              r0 = r3
            else
              self.index = i0
              r0 = nil
            end
          end
        end
        
        node_cache[:terminal][start_index] = r0
        
        return r0
      end
      
      module QuotedString0
        def string
          super.text_value
        end
      end
      
      def _nt_quoted_string
        start_index = index
        cached = node_cache[:quoted_string][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0 = index
        r1 = _nt_single_quoted_string
        if r1
          r0 = r1
          r0.extend(QuotedString0)
        else
          r2 = _nt_double_quoted_string
          if r2
            r0 = r2
            r0.extend(QuotedString0)
          else
            self.index = i0
            r0 = nil
          end
        end
        
        node_cache[:quoted_string][start_index] = r0
        
        return r0
      end
      
      module DoubleQuotedString0
      end
      
      module DoubleQuotedString1
        def string
          elements[1]
        end
        
      end
      
      def _nt_double_quoted_string
        start_index = index
        cached = node_cache[:double_quoted_string][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        if input.index('"', index) == index
          r1 = (SyntaxNode).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('"')
          r1 = nil
        end
        s0 << r1
        if r1
          s2, i2 = [], index
          loop do
            i3, s3 = index, []
            i4 = index
            if input.index('"', index) == index
              r5 = (SyntaxNode).new(input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure('"')
              r5 = nil
            end
            if r5
              r4 = nil
            else
              self.index = i4
              r4 = SyntaxNode.new(input, index...index)
            end
            s3 << r4
            if r4
              i6 = index
              if input.index("\\\\", index) == index
                r7 = (SyntaxNode).new(input, index...(index + 2))
                @index += 2
              else
                terminal_parse_failure("\\\\")
                r7 = nil
              end
              if r7
                r6 = r7
              else
                if input.index('\"', index) == index
                  r8 = (SyntaxNode).new(input, index...(index + 2))
                  @index += 2
                else
                  terminal_parse_failure('\"')
                  r8 = nil
                end
                if r8
                  r6 = r8
                else
                  if index < input_length
                    r9 = (SyntaxNode).new(input, index...(index + 1))
                    @index += 1
                  else
                    terminal_parse_failure("any character")
                    r9 = nil
                  end
                  if r9
                    r6 = r9
                  else
                    self.index = i6
                    r6 = nil
                  end
                end
              end
              s3 << r6
            end
            if s3.last
              r3 = (SyntaxNode).new(input, i3...index, s3)
              r3.extend(DoubleQuotedString0)
            else
              self.index = i3
              r3 = nil
            end
            if r3
              s2 << r3
            else
              break
            end
          end
          r2 = SyntaxNode.new(input, i2...index, s2)
          s0 << r2
          if r2
            if input.index('"', index) == index
              r10 = (SyntaxNode).new(input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure('"')
              r10 = nil
            end
            s0 << r10
          end
        end
        if s0.last
          r0 = (Terminal).new(input, i0...index, s0)
          r0.extend(DoubleQuotedString1)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:double_quoted_string][start_index] = r0
        
        return r0
      end
      
      module SingleQuotedString0
      end
      
      module SingleQuotedString1
        def string
          elements[1]
        end
        
      end
      
      def _nt_single_quoted_string
        start_index = index
        cached = node_cache[:single_quoted_string][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        if input.index("'", index) == index
          r1 = (SyntaxNode).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure("'")
          r1 = nil
        end
        s0 << r1
        if r1
          s2, i2 = [], index
          loop do
            i3, s3 = index, []
            i4 = index
            if input.index("'", index) == index
              r5 = (SyntaxNode).new(input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure("'")
              r5 = nil
            end
            if r5
              r4 = nil
            else
              self.index = i4
              r4 = SyntaxNode.new(input, index...index)
            end
            s3 << r4
            if r4
              i6 = index
              if input.index("\\\\", index) == index
                r7 = (SyntaxNode).new(input, index...(index + 2))
                @index += 2
              else
                terminal_parse_failure("\\\\")
                r7 = nil
              end
              if r7
                r6 = r7
              else
                if input.index("\\'", index) == index
                  r8 = (SyntaxNode).new(input, index...(index + 2))
                  @index += 2
                else
                  terminal_parse_failure("\\'")
                  r8 = nil
                end
                if r8
                  r6 = r8
                else
                  if index < input_length
                    r9 = (SyntaxNode).new(input, index...(index + 1))
                    @index += 1
                  else
                    terminal_parse_failure("any character")
                    r9 = nil
                  end
                  if r9
                    r6 = r9
                  else
                    self.index = i6
                    r6 = nil
                  end
                end
              end
              s3 << r6
            end
            if s3.last
              r3 = (SyntaxNode).new(input, i3...index, s3)
              r3.extend(SingleQuotedString0)
            else
              self.index = i3
              r3 = nil
            end
            if r3
              s2 << r3
            else
              break
            end
          end
          r2 = SyntaxNode.new(input, i2...index, s2)
          s0 << r2
          if r2
            if input.index("'", index) == index
              r10 = (SyntaxNode).new(input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure("'")
              r10 = nil
            end
            s0 << r10
          end
        end
        if s0.last
          r0 = (Terminal).new(input, i0...index, s0)
          r0.extend(SingleQuotedString1)
        else
          self.index = i0
          r0 = nil
        end
        
        node_cache[:single_quoted_string][start_index] = r0
        
        return r0
      end
      
      module CharacterClass0
      end
      
      module CharacterClass1
        def characters
          elements[1]
        end
        
      end
      
      module CharacterClass2
        def characters
          super.text_value
        end
      end
      
      def _nt_character_class
        start_index = index
        cached = node_cache[:character_class][index]
        if cached
          @index = cached.interval.end
          return cached
        end
        
        i0, s0 = index, []
        if input.index('[', index) == index
          r1 = (SyntaxNode).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('[')
          r1 = nil
        end
        s0 << r1
        if r1
          s2, i2 = [], index
          loop do
            i3, s3 = index, []
            i4 = index
            if input.index(']', index) == index
              r5 = (SyntaxNode).new(input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure(']')
              r5 = nil
            end
            if r5
              r4 = nil
            else
              self.index = i4
              r4 = SyntaxNode.new(input, index...index)
            end
            s3 << r4
            if r4
              i6 = index
              if input.index('\]', index) == index
                r7 = (SyntaxNode).new(input, index...(index + 2))
                @index += 2
              else
                terminal_parse_failure('\]')
                r7 = nil
              end
              if r7
                r6 = r7
              else
                if index < input_length
                  r8 = (SyntaxNode).new(input, index...(index + 1))
                  @index += 1
                else
                  terminal_parse_failure("any character")
                  r8 = nil
                end
                if r8
                  r6 = r8
                else
                  self.index = i6
                  r6 = nil
                end
              end
              s3 << r6
            end
            if s3.last
              r3 = (SyntaxNode).new(input, i3...index,