# encoding: UTF-8
# Autogenerated from a Treetop grammar. Edits may be lost.


require "unicode_utils"

module ScientificNameClean
  include Treetop::Runtime

  def root
    @root ||= :root
  end

  module Root0
    def space1
      elements[0]
    end

    def a
      elements[1]
    end

    def space2
      elements[2]
    end
  end

  module Root1
    def value
      a.value.gsub(/\s{2,}/, " ").strip
    end

    def canonical
      a.canonical.gsub(/\s{2,}/, " ").strip
    end

    def pos
      a.pos
    end

    def hybrid
      a.hybrid
    end

    def details
      a.details.class == Array ? a.details : [a.details]
    end

    def parser_run
      1
    end
  end

  def _nt_root
    start_index = index
    if node_cache[:root].has_key?(index)
      cached = node_cache[:root][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_space
    s0 << r1
    if r1
      r2 = _nt_scientific_name_5
      s0 << r2
      if r2
        r3 = _nt_space
        s0 << r3
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(Root0)
      r0.extend(Root1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:root][start_index] = r0

    r0
  end

  module ScientificName50
    def a
      elements[0]
    end

    def space_hard1
      elements[1]
    end

    def hybrid_character
      elements[2]
    end

    def space_hard2
      elements[3]
    end

    def b
      elements[4]
    end
  end

  module ScientificName51
    def value
      a.value + " × " + b.value
    end

    def canonical
      a.canonical + " × " + b.canonical
    end

    def pos
      a.pos.merge(b.pos)
    end

    def hybrid
      true
    end

    def details
      [a.details, b.details.merge({:genus => a.details[:genus]})]
    end
  end

  module ScientificName52
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def b
      elements[2]
    end

    def space2
      elements[3]
    end

    def c
      elements[4]
    end
  end

  module ScientificName53
    def value
      a.value + " " + b.apply(c)
    end

    def canonical
      a.canonical
    end

    def pos
      a.pos.merge(c.pos)
    end

    def hybrid
      a.hybrid
    end

    def details
      a.details.merge(b.details(c))
    end
  end

  def _nt_scientific_name_5
    start_index = index
    if node_cache[:scientific_name_5].has_key?(index)
      cached = node_cache[:scientific_name_5][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_multinomial_name
    s1 << r2
    if r2
      r3 = _nt_space_hard
      s1 << r3
      if r3
        r4 = _nt_hybrid_character
        s1 << r4
        if r4
          r5 = _nt_space_hard
          s1 << r5
          if r5
            r6 = _nt_species
            s1 << r6
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(ScientificName50)
      r1.extend(ScientificName51)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i7, s7 = index, []
      r8 = _nt_scientific_name_1
      s7 << r8
      if r8
        r9 = _nt_space
        s7 << r9
        if r9
          r10 = _nt_taxon_concept_rank
          s7 << r10
          if r10
            r11 = _nt_space
            s7 << r11
            if r11
              r12 = _nt_authorship
              s7 << r12
            end
          end
        end
      end
      if s7.last
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        r7.extend(ScientificName52)
        r7.extend(ScientificName53)
      else
        @index = i7
        r7 = nil
      end
      if r7
        r0 = r7
      else
        r13 = _nt_scientific_name_4
        if r13
          r0 = r13
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:scientific_name_5][start_index] = r0

    r0
  end

  module ScientificName40
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def hybrid_character
      elements[2]
    end

    def space2
      elements[3]
    end

    def b
      elements[4]
    end
  end

  module ScientificName41
    def value
      a.value + " × " + b.value
    end

    def canonical
      a.canonical + " × " + b.canonical
    end

    def pos
      a.pos.merge(b.pos)
    end

    def hybrid
      true
    end

    def details
      [a.details, b.details]
    end
  end

  module ScientificName42
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def hybrid_character
      elements[2]
    end

    def space2
      elements[3]
    end

  end

  module ScientificName43
    def value
      a.value + " × ?"
    end

    def canonical
      a.canonical
    end

    def pos
      a.pos
    end

    def hybrid
      true
    end

    def details
      [a.details, "?"]
    end
  end

  def _nt_scientific_name_4
    start_index = index
    if node_cache[:scientific_name_4].has_key?(index)
      cached = node_cache[:scientific_name_4][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_scientific_name_1
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_hybrid_character
        s1 << r4
        if r4
          r5 = _nt_space
          s1 << r5
          if r5
            r6 = _nt_scientific_name_1
            s1 << r6
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(ScientificName40)
      r1.extend(ScientificName41)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i7, s7 = index, []
      r8 = _nt_scientific_name_1
      s7 << r8
      if r8
        r9 = _nt_space
        s7 << r9
        if r9
          r10 = _nt_hybrid_character
          s7 << r10
          if r10
            r11 = _nt_space
            s7 << r11
            if r11
              if has_terminal?('\G[\\?]', true, index)
                r13 = true
                @index += 1
              else
                r13 = nil
              end
              if r13
                r12 = r13
              else
                r12 = instantiate_node(SyntaxNode,input, index...index)
              end
              s7 << r12
            end
          end
        end
      end
      if s7.last
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        r7.extend(ScientificName42)
        r7.extend(ScientificName43)
      else
        @index = i7
        r7 = nil
      end
      if r7
        r0 = r7
      else
        r14 = _nt_scientific_name_3
        if r14
          r0 = r14
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:scientific_name_4][start_index] = r0

    r0
  end

  module ScientificName30
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module ScientificName31
    def  value
      a.value + " " + b.value
    end

    def canonical
      b.canonical
    end

    def pos
      b.pos
    end

    def hybrid
      true
    end

    def details
      b.details
    end
  end

  def _nt_scientific_name_3
    start_index = index
    if node_cache[:scientific_name_3].has_key?(index)
      cached = node_cache[:scientific_name_3][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_hybrid_character
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_scientific_name_2
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(ScientificName30)
      r1.extend(ScientificName31)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r5 = _nt_scientific_name_2
      if r5
        r0 = r5
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:scientific_name_3][start_index] = r0

    r0
  end

  module ScientificName20
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module ScientificName21
    def value
      a.value + " " + b.value
    end

    def canonical
      a.canonical
    end

    def pos
      a.pos
    end

    def hybrid
      a.hybrid rescue false
    end

    def details
      a.details.merge(b.details)
    end
  end

  def _nt_scientific_name_2
    start_index = index
    if node_cache[:scientific_name_2].has_key?(index)
      cached = node_cache[:scientific_name_2][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_scientific_name_1
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_status_part
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(ScientificName20)
      r1.extend(ScientificName21)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r5 = _nt_scientific_name_1
      if r5
        r0 = r5
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:scientific_name_2][start_index] = r0

    r0
  end

  def _nt_scientific_name_1
    start_index = index
    if node_cache[:scientific_name_1].has_key?(index)
      cached = node_cache[:scientific_name_1][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_multiuninomial_name
    if r1
      r0 = r1
    else
      r2 = _nt_multinomial_name
      if r2
        r0 = r2
      else
        r3 = _nt_uninomial_name
        if r3
          r0 = r3
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:scientific_name_1][start_index] = r0

    r0
  end

  module StatusPart0
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module StatusPart1
    def value
      a.value + " " + b.value
    end
    def details
      {:status => value}
    end
  end

  def _nt_status_part
    start_index = index
    if node_cache[:status_part].has_key?(index)
      cached = node_cache[:status_part][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_status_word
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_status_part
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(StatusPart0)
      r1.extend(StatusPart1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r5 = _nt_status_word
      if r5
        r0 = r5
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:status_part][start_index] = r0

    r0
  end

  module StatusWord0
    def latin_word
      elements[0]
    end

  end

  module StatusWord1
    def value
      text_value.strip
    end
    def details
      {:status => value}
    end
  end

  def _nt_status_word
    start_index = index
    if node_cache[:status_word].has_key?(index)
      cached = node_cache[:status_word][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_latin_word
    s0 << r1
    if r1
      if has_terminal?('\G[\\.]', true, index)
        r2 = true
        @index += 1
      else
        r2 = nil
      end
      s0 << r2
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(StatusWord0)
      r0.extend(StatusWord1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:status_word][start_index] = r0

    r0
  end

  module Unparsed0
    def space
      elements[1]
    end
  end

  module Unparsed1

    def value
      ""
    end

    def hybrid
      false
    end

    def canonical
      ""
    end

    def pos
      {interval.begin => ["unparsed", interval.end]}
    end

    def details
      {:unparsed => text_value}
    end
  end

  def _nt_unparsed
    start_index = index
    if node_cache[:unparsed].has_key?(index)
      cached = node_cache[:unparsed][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    s1, i1 = [], index
    loop do
      if index < input_length
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("any character")
        r2 = nil
      end
      if r2
        s1 << r2
      else
        break
      end
    end
    if s1.empty?
      @index = i1
      r1 = nil
    else
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    end
    s0 << r1
    if r1
      r3 = _nt_space
      s0 << r3
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(Unparsed0)
      r0.extend(Unparsed1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:unparsed][start_index] = r0

    r0
  end

  module MultinomialName0
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def b
      elements[2]
    end

    def space2
      elements[3]
    end

    def aid
      elements[4]
    end

    def space3
      elements[5]
    end

    def c
      elements[6]
    end

    def space_hard
      elements[7]
    end

    def d
      elements[8]
    end
  end

  module MultinomialName1
    def value
      a.value + " " + b.value + " " + c.value + " " + d.value
    end

    def canonical
      a.canonical + " " + c.canonical + " " + d.canonical
    end

    def pos
      a.pos.merge(b.pos).merge(c.pos).merge(d.pos)
    end

    def hybrid
      c.hybrid rescue false
    end

    def details
      a.details.merge(b.details).merge(c.details).merge(d.details)
    end
  end

  module MultinomialName2
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def b
      elements[2]
    end

    def space2
      elements[3]
    end

    def aid1
      elements[4]
    end

    def space3
      elements[5]
    end

    def c
      elements[6]
    end

    def space4
      elements[7]
    end

    def aid2
      elements[8]
    end

    def space5
      elements[9]
    end

    def d
      elements[10]
    end
  end

  module MultinomialName3
    def value
      a.value + " " + b.value + " " + c.value + " " + d.value
    end

    def canonical
      a.canonical + " " + c.canonical + " " + d.canonical
    end

    def pos
      a.pos.merge(b.pos).merge(c.pos).merge(d.pos)
    end

    def hybrid
      c.hybrid rescue false
    end

    def details
      a.details.merge(b.details).merge(c.details).merge(d.details)
    end
  end

  module MultinomialName4
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def b
      elements[2]
    end

    def space2
      elements[3]
    end

    def aid
      elements[4]
    end

    def space3
      elements[5]
    end

    def c
      elements[6]
    end
  end

  module MultinomialName5
    def value
      if defined? aid.apply
        a.value + " " + b.value + aid.apply(c)
      else
        a.value + " " + b.value + " " + c.value
      end
    end

    def canonical
      if defined? aid.apply
        a.canonical + aid.canonical(c)
      else
        a.canonical + " " + c.canonical
      end
    end

    def pos
      if defined? aid.apply
        a.pos.merge(b.pos).merge(aid.pos(c))
      else
        a.pos.merge(b.pos).merge(c.pos)
      end
    end

    def hybrid
      c.hybrid rescue false
    end

    def details
      if defined? aid.apply
        a.details.merge(b.details).merge(aid.apply(c))
      else
        a.details.merge(b.details).merge(c.details)
      end
    end
  end

  module MultinomialName6
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def aid
      elements[2]
    end

    def space2
      elements[3]
    end

    def b
      elements[4]
    end

    def space_hard
      elements[5]
    end

    def c
      elements[6]
    end
  end

  module MultinomialName7
    def value
      a.value + " " + b.value + " " + c.value
    end

    def canonical
      a.canonical + " " + b.canonical + " " + c.canonical
    end

    def pos
      a.pos.merge(b.pos).merge(c.pos)
    end

    def hybrid
      b.hybrid rescue false
    end

    def details
      a.details.merge(b.details).merge(c.details)
    end
  end

  module MultinomialName8
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def aid
      elements[2]
    end

    def space2
      elements[3]
    end

    def b
      elements[4]
    end
  end

  module MultinomialName9
    def value
      if defined? aid.apply
        a.value + aid.apply(b)
      else
        a.value + " " + b.value
      end
    end

    def canonical
      if defined? aid.apply
        a.canonical + aid.canonical(b)
      else
        a.canonical + " " + b.canonical
      end
    end

    def pos
      if defined? aid.apply
        a.pos.merge(aid.pos(b))
      else
        a.pos.merge(b.pos)
      end
    end

    def hybrid
      b.hybrid rescue false
    end

    def details
      if defined? aid.apply
        a.details.merge(aid.details(b))
      else
        a.details.merge(b.details)
      end
    end
  end

  module MultinomialName10
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def aid
      elements[2]
    end

    def space2
      elements[3]
    end

    def b
      elements[4]
    end
  end

  module MultinomialName11
    def value
      a.value + aid.apply(b)
    end

    def canonical
      a.canonical + aid.canonical(b)
    end

    def pos
      a.pos.merge(aid.pos(b))
    end

    def hybrid
      false
    end

    def details
      a.details.merge(aid.details(b))
    end
  end

  def _nt_multinomial_name
    start_index = index
    if node_cache[:multinomial_name].has_key?(index)
      cached = node_cache[:multinomial_name][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_genus
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_infragenus
        s1 << r4
        if r4
          r5 = _nt_space
          s1 << r5
          if r5
            r7 = _nt_annotation_identification
            if r7
              r6 = r7
            else
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s1 << r6
            if r6
              r8 = _nt_space
              s1 << r8
              if r8
                r9 = _nt_species
                s1 << r9
                if r9
                  r10 = _nt_space_hard
                  s1 << r10
                  if r10
                    r11 = _nt_infraspecies_mult
                    s1 << r11
                  end
                end
              end
            end
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(MultinomialName0)
      r1.extend(MultinomialName1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i12, s12 = index, []
      r13 = _nt_genus
      s12 << r13
      if r13
        r14 = _nt_space
        s12 << r14
        if r14
          r15 = _nt_infragenus
          s12 << r15
          if r15
            r16 = _nt_space
            s12 << r16
            if r16
              r18 = _nt_annotation_identification
              if r18
                r17 = r18
              else
                r17 = instantiate_node(SyntaxNode,input, index...index)
              end
              s12 << r17
              if r17
                r19 = _nt_space
                s12 << r19
                if r19
                  r20 = _nt_species
                  s12 << r20
                  if r20
                    r21 = _nt_space
                    s12 << r21
                    if r21
                      r22 = _nt_annotation_identification
                      s12 << r22
                      if r22
                        r23 = _nt_space
                        s12 << r23
                        if r23
                          r24 = _nt_infraspecies_mult
                          s12 << r24
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
      if s12.last
        r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
        r12.extend(MultinomialName2)
        r12.extend(MultinomialName3)
      else
        @index = i12
        r12 = nil
      end
      if r12
        r0 = r12
      else
        i25, s25 = index, []
        r26 = _nt_genus
        s25 << r26
        if r26
          r27 = _nt_space
          s25 << r27
          if r27
            r28 = _nt_infragenus
            s25 << r28
            if r28
              r29 = _nt_space
              s25 << r29
              if r29
                r31 = _nt_annotation_identification
                if r31
                  r30 = r31
                else
                  r30 = instantiate_node(SyntaxNode,input, index...index)
                end
                s25 << r30
                if r30
                  r32 = _nt_space
                  s25 << r32
                  if r32
                    r33 = _nt_species
                    s25 << r33
                  end
                end
              end
            end
          end
        end
        if s25.last
          r25 = instantiate_node(SyntaxNode,input, i25...index, s25)
          r25.extend(MultinomialName4)
          r25.extend(MultinomialName5)
        else
          @index = i25
          r25 = nil
        end
        if r25
          r0 = r25
        else
          i34, s34 = index, []
          r35 = _nt_genus
          s34 << r35
          if r35
            r36 = _nt_space
            s34 << r36
            if r36
              r38 = _nt_annotation_identification
              if r38
                r37 = r38
              else
                r37 = instantiate_node(SyntaxNode,input, index...index)
              end
              s34 << r37
              if r37
                r39 = _nt_space
                s34 << r39
                if r39
                  r40 = _nt_species
                  s34 << r40
                  if r40
                    r41 = _nt_space_hard
                    s34 << r41
                    if r41
                      r42 = _nt_infraspecies_mult
                      s34 << r42
                    end
                  end
                end
              end
            end
          end
          if s34.last
            r34 = instantiate_node(SyntaxNode,input, i34...index, s34)
            r34.extend(MultinomialName6)
            r34.extend(MultinomialName7)
          else
            @index = i34
            r34 = nil
          end
          if r34
            r0 = r34
          else
            i43, s43 = index, []
            r44 = _nt_genus
            s43 << r44
            if r44
              r45 = _nt_space
              s43 << r45
              if r45
                r47 = _nt_annotation_identification
                if r47
                  r46 = r47
                else
                  r46 = instantiate_node(SyntaxNode,input, index...index)
                end
                s43 << r46
                if r46
                  r48 = _nt_space
                  s43 << r48
                  if r48
                    r49 = _nt_species
                    s43 << r49
                  end
                end
              end
            end
            if s43.last
              r43 = instantiate_node(SyntaxNode,input, i43...index, s43)
              r43.extend(MultinomialName8)
              r43.extend(MultinomialName9)
            else
              @index = i43
              r43 = nil
            end
            if r43
              r0 = r43
            else
              i50, s50 = index, []
              r51 = _nt_genus
              s50 << r51
              if r51
                r52 = _nt_space
                s50 << r52
                if r52
                  r53 = _nt_annotation_identification
                  s50 << r53
                  if r53
                    r54 = _nt_space
                    s50 << r54
                    if r54
                      r55 = _nt_unparsed
                      s50 << r55
                    end
                  end
                end
              end
              if s50.last
                r50 = instantiate_node(SyntaxNode,input, i50...index, s50)
                r50.extend(MultinomialName10)
                r50.extend(MultinomialName11)
              else
                @index = i50
                r50 = nil
              end
              if r50
                r0 = r50
              else
                @index = i0
                r0 = nil
              end
            end
          end
        end
      end
    end

    node_cache[:multinomial_name][start_index] = r0

    r0
  end

  module MultiuninomialName0
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def b
      elements[2]
    end

    def space2
      elements[3]
    end

    def c
      elements[4]
    end
  end

  module MultiuninomialName1

    def value
      a.value + " " + b.value + " " + c.value
    end

    def canonical
      a.canonical
    end

    def hybrid
      false
    end

    def pos
      a.pos.merge(b.pos(c))
    end

    def details
      a.details.merge(b.details(c))
    end
  end

  def _nt_multiuninomial_name
    start_index = index
    if node_cache[:multiuninomial_name].has_key?(index)
      cached = node_cache[:multiuninomial_name][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_uninomial_name
    s0 << r1
    if r1
      r2 = _nt_space
      s0 << r2
      if r2
        r3 = _nt_rank_uninomial
        s0 << r3
        if r3
          r4 = _nt_space
          s0 << r4
          if r4
            r5 = _nt_uninomial_name
            s0 << r5
          end
        end
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(MultiuninomialName0)
      r0.extend(MultiuninomialName1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:multiuninomial_name][start_index] = r0

    r0
  end

  module InfraspeciesMult0
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module InfraspeciesMult1
    def value
      a.value + " " + b.value
    end

    def canonical
      a.canonical + " " + b.canonical
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      a_array =  a.details[:infraspecies].class == Array ? a.details[:infraspecies] : [a.details[:infraspecies]]
      b_array = b.details[:infraspecies].class == Array ? b.details[:infraspecies] : [b.details[:infraspecies]]
      a.details.merge({:infraspecies => a_array + b_array})
    end
  end

  module InfraspeciesMult2
    def details
      if super[:annotation_identification]
        {:infraspecies => [{:annotation_identification => super[:annotation_identification], :ignored => super[:ignored]}]}
      else
        {:infraspecies => [super[:infraspecies]]}
      end
    end
  end

  def _nt_infraspecies_mult
    start_index = index
    if node_cache[:infraspecies_mult].has_key?(index)
      cached = node_cache[:infraspecies_mult][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_infraspecies
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_infraspecies_mult
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(InfraspeciesMult0)
      r1.extend(InfraspeciesMult1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r5 = _nt_infraspecies
      r5.extend(InfraspeciesMult2)
      if r5
        r0 = r5
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:infraspecies_mult][start_index] = r0

    r0
  end

  module Infraspecies0
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module Infraspecies1
    def value
      a.value + " " + b.value
    end

    def canonical
      a.canonical
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      {:infraspecies => a.details[:infraspecies].merge(b.details)}
    end
  end

  def _nt_infraspecies
    start_index = index
    if node_cache[:infraspecies].has_key?(index)
      cached = node_cache[:infraspecies][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_infraspecies_string
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_authorship
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Infraspecies0)
      r1.extend(Infraspecies1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r5 = _nt_infraspecies_string
      if r5
        r0 = r5
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:infraspecies][start_index] = r0

    r0
  end

  module InfraspeciesString0
    def sel
      elements[0]
    end

    def space
      elements[1]
    end

    def a
      elements[2]
    end
  end

  module InfraspeciesString1
    def value
      sel.apply(a)
    end
    def canonical
      sel.canonical(a)
    end

    def pos
      sel.pos(a)
    end

    def details
      sel.details(a)
    end
  end

  module InfraspeciesString2
    def aid
      elements[0]
    end

    def space
      elements[1]
    end

    def a
      elements[2]
    end

  end

  module InfraspeciesString3
    def value
      aid.apply(a)
    end

    def canonical
      aid.canonical(a)
    end

    def pos
      def a.pos
        {interval.begin => ["infraspecies", a.interval.end]}
      end
      aid.pos(a)
    end

    def details
      def a.details
        {:infraspecies => {:string => value, :rank => "n/a"}}
      end
      aid.details(a)
    end
  end

  module InfraspeciesString4
    def a
      elements[0]
    end

  end

  module InfraspeciesString5
    def value
      a.value
    end

    def canonical
      value
    end

    def pos
      {interval.begin => ["infraspecies", interval.end]}
    end

    def details
      {:infraspecies => {:string => value, :rank => "n/a"}}
    end
  end

  def _nt_infraspecies_string
    start_index = index
    if node_cache[:infraspecies_string].has_key?(index)
      cached = node_cache[:infraspecies_string][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_rank
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_species_word
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(InfraspeciesString0)
      r1.extend(InfraspeciesString1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i5, s5 = index, []
      r6 = _nt_annotation_identification
      s5 << r6
      if r6
        r7 = _nt_space
        s5 << r7
        if r7
          r8 = _nt_species_word
          s5 << r8
          if r8
            i9 = index
            if has_terminal?('\G[\\.]', true, index)
              r10 = true
              @index += 1
            else
              r10 = nil
            end
            if r10
              r9 = nil
            else
              @index = i9
              r9 = instantiate_node(SyntaxNode,input, index...index)
            end
            s5 << r9
          end
        end
      end
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(InfraspeciesString2)
        r5.extend(InfraspeciesString3)
      else
        @index = i5
        r5 = nil
      end
      if r5
        r0 = r5
      else
        i11, s11 = index, []
        r12 = _nt_species_word
        s11 << r12
        if r12
          i13 = index
          if has_terminal?('\G[\\.]', true, index)
            r14 = true
            @index += 1
          else
            r14 = nil
          end
          if r14
            r13 = nil
          else
            @index = i13
            r13 = instantiate_node(SyntaxNode,input, index...index)
          end
          s11 << r13
        end
        if s11.last
          r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
          r11.extend(InfraspeciesString4)
          r11.extend(InfraspeciesString5)
        else
          @index = i11
          r11 = nil
        end
        if r11
          r0 = r11
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:infraspecies_string][start_index] = r0

    r0
  end

  module TaxonConceptRank0
    def value
      "sec."
    end
    def apply(a)
      " " + value + " " + a.value
    end
    def details(a = nil)
      {:taxon_concept => a.details}
    end
  end

  def _nt_taxon_concept_rank
    start_index = index
    if node_cache[:taxon_concept_rank].has_key?(index)
      cached = node_cache[:taxon_concept_rank][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    if has_terminal?("sec.", false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
      @index += 4
    else
      terminal_parse_failure("sec.")
      r1 = nil
    end
    if r1
      r0 = r1
      r0.extend(TaxonConceptRank0)
    else
      if has_terminal?("sensu.", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 6))
        @index += 6
      else
        terminal_parse_failure("sensu.")
        r2 = nil
      end
      if r2
        r0 = r2
        r0.extend(TaxonConceptRank0)
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:taxon_concept_rank][start_index] = r0

    r0
  end

  module Rank0
    def value
      text_value.strip
    end

    def apply(a)
      " " + text_value.strip + " " + a.value
    end

    def canonical(a)
      " " + a.value
    end

    def pos(a)
      interval_end =  text_value[-1] == " " ? interval.end - 1 : interval.end
      {interval.begin => ["infraspecific_type", interval_end], a.interval.begin => ["infraspecies", a.interval.end]}
    end

    def details(a = nil)
      {:infraspecies => {:string => (a.value rescue nil), :rank => text_value.strip}}
    end
  end

  def _nt_rank
    start_index = index
    if node_cache[:rank].has_key?(index)
      cached = node_cache[:rank][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    if has_terminal?("morph.", false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 6))
      @index += 6
    else
      terminal_parse_failure("morph.")
      r1 = nil
    end
    if r1
      r0 = r1
      r0.extend(Rank0)
    else
      if has_terminal?("f.sp.", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 5))
        @index += 5
      else
        terminal_parse_failure("f.sp.")
        r2 = nil
      end
      if r2
        r0 = r2
        r0.extend(Rank0)
      else
        if has_terminal?("B ", false, index)
          r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
          @index += 2
        else
          terminal_parse_failure("B ")
          r3 = nil
        end
        if r3
          r0 = r3
          r0.extend(Rank0)
        else
          if has_terminal?("ssp.", false, index)
            r4 = instantiate_node(SyntaxNode,input, index...(index + 4))
            @index += 4
          else
            terminal_parse_failure("ssp.")
            r4 = nil
          end
          if r4
            r0 = r4
            r0.extend(Rank0)
          else
            if has_terminal?("ssp ", false, index)
              r5 = instantiate_node(SyntaxNode,input, index...(index + 4))
              @index += 4
            else
              terminal_parse_failure("ssp ")
              r5 = nil
            end
            if r5
              r0 = r5
              r0.extend(Rank0)
            else
              if has_terminal?("mut.", false, index)
                r6 = instantiate_node(SyntaxNode,input, index...(index + 4))
                @index += 4
              else
                terminal_parse_failure("mut.")
                r6 = nil
              end
              if r6
                r0 = r6
                r0.extend(Rank0)
              else
                if has_terminal?("nat ", false, index)
                  r7 = instantiate_node(SyntaxNode,input, index...(index + 4))
                  @index += 4
                else
                  terminal_parse_failure("nat ")
                  r7 = nil
                end
                if r7
                  r0 = r7
                  r0.extend(Rank0)
                else
                  if has_terminal?("nothosubsp.", false, index)
                    r8 = instantiate_node(SyntaxNode,input, index...(index + 11))
                    @index += 11
                  else
                    terminal_parse_failure("nothosubsp.")
                    r8 = nil
                  end
                  if r8
                    r0 = r8
                    r0.extend(Rank0)
                  else
                    if has_terminal?("convar.", false, index)
                      r9 = instantiate_node(SyntaxNode,input, index...(index + 7))
                      @index += 7
                    else
                      terminal_parse_failure("convar.")
                      r9 = nil
                    end
                    if r9
                      r0 = r9
                      r0.extend(Rank0)
                    else
                      if has_terminal?("pseudovar.", false, index)
                        r10 = instantiate_node(SyntaxNode,input, index...(index + 10))
                        @index += 10
                      else
                        terminal_parse_failure("pseudovar.")
                        r10 = nil
                      end
                      if r10
                        r0 = r10
                        r0.extend(Rank0)
                      else
                        if has_terminal?("sect.", false, index)
                          r11 = instantiate_node(SyntaxNode,input, index...(index + 5))
                          @index += 5
                        else
                          terminal_parse_failure("sect.")
                          r11 = nil
                        end
                        if r11
                          r0 = r11
                          r0.extend(Rank0)
                        else
                          if has_terminal?("ser.", false, index)
                            r12 = instantiate_node(SyntaxNode,input, index...(index + 4))
                            @index += 4
                          else
                            terminal_parse_failure("ser.")
                            r12 = nil
                          end
                          if r12
                            r0 = r12
                            r0.extend(Rank0)
                          else
                            if has_terminal?("var.", false, index)
                              r13 = instantiate_node(SyntaxNode,input, index...(index + 4))
                              @index += 4
                            else
                              terminal_parse_failure("var.")
                              r13 = nil
                            end
                            if r13
                              r0 = r13
                              r0.extend(Rank0)
                            else
                              if has_terminal?("subvar.", false, index)
                                r14 = instantiate_node(SyntaxNode,input, index...(index + 7))
                                @index += 7
                              else
                                terminal_parse_failure("subvar.")
                                r14 = nil
                              end
                              if r14
                                r0 = r14
                                r0.extend(Rank0)
                              else
                                if has_terminal?("[var.]", false, index)
                                  r15 = instantiate_node(SyntaxNode,input, index...(index + 6))
                                  @index += 6
                                else
                                  terminal_parse_failure("[var.]")
                                  r15 = nil
                                end
                                if r15
                                  r0 = r15
                                  r0.extend(Rank0)
                                else
                                  if has_terminal?("var ", false, index)
                                    r16 = instantiate_node(SyntaxNode,input, index...(index + 4))
                                    @index += 4
                                  else
                                    terminal_parse_failure("var ")
                                    r16 = nil
                                  end
                                  if r16
                                    r0 = r16
                                    r0.extend(Rank0)
                                  else
                                    if has_terminal?("subsp.", false, index)
                                      r17 = instantiate_node(SyntaxNode,input, index...(index + 6))
                                      @index += 6
                                    else
                                      terminal_parse_failure("subsp.")
                                      r17 = nil
                                    end
                                    if r17
                                      r0 = r17
                                      r0.extend(Rank0)
                                    else
                                      if has_terminal?("subsp ", false, index)
                                        r18 = instantiate_node(SyntaxNode,input, index...(index + 6))
                                        @index += 6
                                      else
                                        terminal_parse_failure("subsp ")
                                        r18 = nil
                                      end
                                      if r18
                                        r0 = r18
                                        r0.extend(Rank0)
                                      else
                                        if has_terminal?("subf.", false, index)
                                          r19 = instantiate_node(SyntaxNode,input, index...(index + 5))
                                          @index += 5
                                        else
                                          terminal_parse_failure("subf.")
                                          r19 = nil
                                        end
                                        if r19
                                          r0 = r19
                                          r0.extend(Rank0)
                                        else
                                          if has_terminal?("race ", false, index)
                                            r20 = instantiate_node(SyntaxNode,input, index...(index + 5))
                                            @index += 5
                                          else
                                            terminal_parse_failure("race ")
                                            r20 = nil
                                          end
                                          if r20
                                            r0 = r20
                                            r0.extend(Rank0)
                                          else
                                            if has_terminal?("forma.", false, index)
                                              r21 = instantiate_node(SyntaxNode,input, index...(index + 6))
                                              @index += 6
                                            else
                                              terminal_parse_failure("forma.")
                                              r21 = nil
                                            end
                                            if r21
                                              r0 = r21
                                              r0.extend(Rank0)
                                            else
                                              if has_terminal?("forma ", false, index)
                                                r22 = instantiate_node(SyntaxNode,input, index...(index + 6))
                                                @index += 6
                                              else
                                                terminal_parse_failure("forma ")
                                                r22 = nil
                                              end
                                              if r22
                                                r0 = r22
                                                r0.extend(Rank0)
                                              else
                                                if has_terminal?("fma.", false, index)
                                                  r23 = instantiate_node(SyntaxNode,input, index...(index + 4))
                                                  @index += 4
                                                else
                                                  terminal_parse_failure("fma.")
                                                  r23 = nil
                                                end
                                                if r23
                                                  r0 = r23
                                                  r0.extend(Rank0)
                                                else
                                                  if has_terminal?("fma ", false, index)
                                                    r24 = instantiate_node(SyntaxNode,input, index...(index + 4))
                                                    @index += 4
                                                  else
                                                    terminal_parse_failure("fma ")
                                                    r24 = nil
                                                  end
                                                  if r24
                                                    r0 = r24
                                                    r0.extend(Rank0)
                                                  else
                                                    if has_terminal?("form.", false, index)
                                                      r25 = instantiate_node(SyntaxNode,input, index...(index + 5))
                                                      @index += 5
                                                    else
                                                      terminal_parse_failure("form.")
                                                      r25 = nil
                                                    end
                                                    if r25
                                                      r0 = r25
                                                      r0.extend(Rank0)
                                                    else
                                                      if has_terminal?("form ", false, index)
                                                        r26 = instantiate_node(SyntaxNode,input, index...(index + 5))
                                                        @index += 5
                                                      else
                                                        terminal_parse_failure("form ")
                                                        r26 = nil
                                                      end
                                                      if r26
                                                        r0 = r26
                                                        r0.extend(Rank0)
                                                      else
                                                        if has_terminal?("fo.", false, index)
                                                          r27 = instantiate_node(SyntaxNode,input, index...(index + 3))
                                                          @index += 3
                                                        else
                                                          terminal_parse_failure("fo.")
                                                          r27 = nil
                                                        end
                                                        if r27
                                                          r0 = r27
                                                          r0.extend(Rank0)
                                                        else
                                                          if has_terminal?("fo ", false, index)
                                                            r28 = instantiate_node(SyntaxNode,input, index...(index + 3))
                                                            @index += 3
                                                          else
                                                            terminal_parse_failure("fo ")
                                                            r28 = nil
                                                          end
                                                          if r28
                                                            r0 = r28
                                                            r0.extend(Rank0)
                                                          else
                                                            if has_terminal?("f.", false, index)
                                                              r29 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                              @index += 2
                                                            else
                                                              terminal_parse_failure("f.")
                                                              r29 = nil
                                                            end
                                                            if r29
                                                              r0 = r29
                                                              r0.extend(Rank0)
                                                            else
                                                              if has_terminal?("α", false, index)
                                                                r30 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                @index += 1
                                                              else
                                                                terminal_parse_failure("α")
                                                                r30 = nil
                                                              end
                                                              if r30
                                                                r0 = r30
                                                                r0.extend(Rank0)
                                                              else
                                                                if has_terminal?("ββ", false, index)
                                                                  r31 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                  @index += 2
                                                                else
                                                                  terminal_parse_failure("ββ")
                                                                  r31 = nil
                                                                end
                                                                if r31
                                                                  r0 = r31
                                                                  r0.extend(Rank0)
                                                                else
                                                                  if has_terminal?("β", false, index)
                                                                    r32 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                    @index += 1
                                                                  else
                                                                    terminal_parse_failure("β")
                                                                    r32 = nil
                                                                  end
                                                                  if r32
                                                                    r0 = r32
                                                                    r0.extend(Rank0)
                                                                  else
                                                                    if has_terminal?("γ", false, index)
                                                                      r33 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                      @index += 1
                                                                    else
                                                                      terminal_parse_failure("γ")
                                                                      r33 = nil
                                                                    end
                                                                    if r33
                                                                      r0 = r33
                                                                      r0.extend(Rank0)
                                                                    else
                                                                      if has_terminal?("δ", false, index)
                                                                        r34 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                        @index += 1
                                                                      else
                                                                        terminal_parse_failure("δ")
                                                                        r34 = nil
                                                                      end
                                                                      if r34
                                                                        r0 = r34
                                                                        r0.extend(Rank0)
                                                                      else
                                                                        if has_terminal?("ε", false, index)
                                                                          r35 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                          @index += 1
                                                                        else
                                                                          terminal_parse_failure("ε")
                                                                          r35 = nil
                                                                        end
                                                                        if r35
                                                                          r0 = r35
                                                                          r0.extend(Rank0)
                                                                        else
                                                                          if has_terminal?("φ", false, index)
                                                                            r36 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                            @index += 1
                                                                          else
                                                                            terminal_parse_failure("φ")
                                                                            r36 = nil
                                                                          end
                                                                          if r36
                                                                            r0 = r36
                                                                            r0.extend(Rank0)
                                                                          else
                                                                            if has_terminal?("θ", false, index)
                                                                              r37 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                              @index += 1
                                                                            else
                                                                              terminal_parse_failure("θ")
                                                                              r37 = nil
                                                                            end
                                                                            if r37
                                                                              r0 = r37
                                                                              r0.extend(Rank0)
                                                                            else
                                                                              if has_terminal?("μ", false, index)
                                                                                r38 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                                @index += 1
                                                                              else
                                                                                terminal_parse_failure("μ")
                                                                                r38 = nil
                                                                              end
                                                                              if r38
                                                                                r0 = r38
                                                                                r0.extend(Rank0)
                                                                              else
                                                                                if has_terminal?("a.", false, index)
                                                                                  r39 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                  @index += 2
                                                                                else
                                                                                  terminal_parse_failure("a.")
                                                                                  r39 = nil
                                                                                end
                                                                                if r39
                                                                                  r0 = r39
                                                                                  r0.extend(Rank0)
                                                                                else
                                                                                  if has_terminal?("b.", false, index)
                                                                                    r40 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                    @index += 2
                                                                                  else
                                                                                    terminal_parse_failure("b.")
                                                                                    r40 = nil
                                                                                  end
                                                                                  if r40
                                                                                    r0 = r40
                                                                                    r0.extend(Rank0)
                                                                                  else
                                                                                    if has_terminal?("c.", false, index)
                                                                                      r41 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                      @index += 2
                                                                                    else
                                                                                      terminal_parse_failure("c.")
                                                                                      r41 = nil
                                                                                    end
                                                                                    if r41
                                                                                      r0 = r41
                                                                                      r0.extend(Rank0)
                                                                                    else
                                                                                      if has_terminal?("d.", false, index)
                                                                                        r42 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                        @index += 2
                                                                                      else
                                                                                        terminal_parse_failure("d.")
                                                                                        r42 = nil
                                                                                      end
                                                                                      if r42
                                                                                        r0 = r42
                                                                                        r0.extend(Rank0)
                                                                                      else
                                                                                        if has_terminal?("e.", false, index)
                                                                                          r43 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                          @index += 2
                                                                                        else
                                                                                          terminal_parse_failure("e.")
                                                                                          r43 = nil
                                                                                        end
                                                                                        if r43
                                                                                          r0 = r43
                                                                                          r0.extend(Rank0)
                                                                                        else
                                                                                          if has_terminal?("g.", false, index)
                                                                                            r44 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                            @index += 2
                                                                                          else
                                                                                            terminal_parse_failure("g.")
                                                                                            r44 = nil
                                                                                          end
                                                                                          if r44
                                                                                            r0 = r44
                                                                                            r0.extend(Rank0)
                                                                                          else
                                                                                            if has_terminal?("k.", false, index)
                                                                                              r45 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                              @index += 2
                                                                                            else
                                                                                              terminal_parse_failure("k.")
                                                                                              r45 = nil
                                                                                            end
                                                                                            if r45
                                                                                              r0 = r45
                                                                                              r0.extend(Rank0)
                                                                                            else
                                                                                              if has_terminal?("****", false, index)
                                                                                                r46 = instantiate_node(SyntaxNode,input, index...(index + 4))
                                                                                                @index += 4
                                                                                              else
                                                                                                terminal_parse_failure("****")
                                                                                                r46 = nil
                                                                                              end
                                                                                              if r46
                                                                                                r0 = r46
                                                                                                r0.extend(Rank0)
                                                                                              else
                                                                                                if has_terminal?("**", false, index)
                                                                                                  r47 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                                  @index += 2
                                                                                                else
                                                                                                  terminal_parse_failure("**")
                                                                                                  r47 = nil
                                                                                                end
                                                                                                if r47
                                                                                                  r0 = r47
                                                                                                  r0.extend(Rank0)
                                                                                                else
                                                                                                  if has_terminal?("*", false, index)
                                                                                                    r48 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                                                                    @index += 1
                                                                                                  else
                                                                                                    terminal_parse_failure("*")
                                                                                                    r48 = nil
                                                                                                  end
                                                                                                  if r48
                                                                                                    r0 = r48
                                                                                                    r0.extend(Rank0)
                                                                                                  else
                                                                                                    @index = i0
                                                                                                    r0 = nil
                                                                                                  end
                                                                                                end
                                                                                              end
                                                                                            end
                                                                                          end
                                                                                        end
                                                                                      end
                                                                                    end
                                                                                  end
                                                                                end
                                                                              end
                                                                            end
                                                                          end
                                                                        end
                                                                      end
                                                                    end
                                                                  end
                                                                end
                                                              end
                                                            end
                                                          end
                                                        end
                                                      end
                                                    end
                                                  end
                                                end
                                              end
                                            end
                                          end
                                        end
                                      end
                                    end
                                  end
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end

    node_cache[:rank][start_index] = r0

    r0
  end

  module RankUninomial0
    def value
      text_value.strip
    end

    def pos(uni)
      {interval.begin => ["rank_uninomial", interval.end], uni.interval.begin => ["uninomial", uni.interval.end]}
    end

    def details(uni)
      {:rank_uninomials => value, :uninomial2 => uni.details[:uninomial]}
    end
  end

  def _nt_rank_uninomial
    start_index = index
    if node_cache[:rank_uninomial].has_key?(index)
      cached = node_cache[:rank_uninomial][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    if has_terminal?("sect.", false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 5))
      @index += 5
    else
      terminal_parse_failure("sect.")
      r1 = nil
    end
    if r1
      r0 = r1
      r0.extend(RankUninomial0)
    else
      if has_terminal?("sect ", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 5))
        @index += 5
      else
        terminal_parse_failure("sect ")
        r2 = nil
      end
      if r2
        r0 = r2
        r0.extend(RankUninomial0)
      else
        if has_terminal?("subsect.", false, index)
          r3 = instantiate_node(SyntaxNode,input, index...(index + 8))
          @index += 8
        else
          terminal_parse_failure("subsect.")
          r3 = nil
        end
        if r3
          r0 = r3
          r0.extend(RankUninomial0)
        else
          if has_terminal?("subsect ", false, index)
            r4 = instantiate_node(SyntaxNode,input, index...(index + 8))
            @index += 8
          else
            terminal_parse_failure("subsect ")
            r4 = nil
          end
          if r4
            r0 = r4
            r0.extend(RankUninomial0)
          else
            if has_terminal?("trib.", false, index)
              r5 = instantiate_node(SyntaxNode,input, index...(index + 5))
              @index += 5
            else
              terminal_parse_failure("trib.")
              r5 = nil
            end
            if r5
              r0 = r5
              r0.extend(RankUninomial0)
            else
              if has_terminal?("trib ", false, index)
                r6 = instantiate_node(SyntaxNode,input, index...(index + 5))
                @index += 5
              else
                terminal_parse_failure("trib ")
                r6 = nil
              end
              if r6
                r0 = r6
                r0.extend(RankUninomial0)
              else
                if has_terminal?("subtrib.", false, index)
                  r7 = instantiate_node(SyntaxNode,input, index...(index + 8))
                  @index += 8
                else
                  terminal_parse_failure("subtrib.")
                  r7 = nil
                end
                if r7
                  r0 = r7
                  r0.extend(RankUninomial0)
                else
                  if has_terminal?("subtrib ", false, index)
                    r8 = instantiate_node(SyntaxNode,input, index...(index + 8))
                    @index += 8
                  else
                    terminal_parse_failure("subtrib ")
                    r8 = nil
                  end
                  if r8
                    r0 = r8
                    r0.extend(RankUninomial0)
                  else
                    if has_terminal?("ser.", false, index)
                      r9 = instantiate_node(SyntaxNode,input, index...(index + 4))
                      @index += 4
                    else
                      terminal_parse_failure("ser.")
                      r9 = nil
                    end
                    if r9
                      r0 = r9
                      r0.extend(RankUninomial0)
                    else
                      if has_terminal?("ser ", false, index)
                        r10 = instantiate_node(SyntaxNode,input, index...(index + 4))
                        @index += 4
                      else
                        terminal_parse_failure("ser ")
                        r10 = nil
                      end
                      if r10
                        r0 = r10
                        r0.extend(RankUninomial0)
                      else
                        if has_terminal?("subgen.", false, index)
                          r11 = instantiate_node(SyntaxNode,input, index...(index + 7))
                          @index += 7
                        else
                          terminal_parse_failure("subgen.")
                          r11 = nil
                        end
                        if r11
                          r0 = r11
                          r0.extend(RankUninomial0)
                        else
                          if has_terminal?("subgen ", false, index)
                            r12 = instantiate_node(SyntaxNode,input, index...(index + 7))
                            @index += 7
                          else
                            terminal_parse_failure("subgen ")
                            r12 = nil
                          end
                          if r12
                            r0 = r12
                            r0.extend(RankUninomial0)
                          else
                            if has_terminal?("fam.", false, index)
                              r13 = instantiate_node(SyntaxNode,input, index...(index + 4))
                              @index += 4
                            else
                              terminal_parse_failure("fam.")
                              r13 = nil
                            end
                            if r13
                              r0 = r13
                              r0.extend(RankUninomial0)
                            else
                              if has_terminal?("fam ", false, index)
                                r14 = instantiate_node(SyntaxNode,input, index...(index + 4))
                                @index += 4
                              else
                                terminal_parse_failure("fam ")
                                r14 = nil
                              end
                              if r14
                                r0 = r14
                                r0.extend(RankUninomial0)
                              else
                                if has_terminal?("subfam.", false, index)
                                  r15 = instantiate_node(SyntaxNode,input, index...(index + 7))
                                  @index += 7
                                else
                                  terminal_parse_failure("subfam.")
                                  r15 = nil
                                end
                                if r15
                                  r0 = r15
                                  r0.extend(RankUninomial0)
                                else
                                  if has_terminal?("subfam ", false, index)
                                    r16 = instantiate_node(SyntaxNode,input, index...(index + 7))
                                    @index += 7
                                  else
                                    terminal_parse_failure("subfam ")
                                    r16 = nil
                                  end
                                  if r16
                                    r0 = r16
                                    r0.extend(RankUninomial0)
                                  else
                                    if has_terminal?("supertrib.", false, index)
                                      r17 = instantiate_node(SyntaxNode,input, index...(index + 10))
                                      @index += 10
                                    else
                                      terminal_parse_failure("supertrib.")
                                      r17 = nil
                                    end
                                    if r17
                                      r0 = r17
                                      r0.extend(RankUninomial0)
                                    else
                                      if has_terminal?("supertrib ", false, index)
                                        r18 = instantiate_node(SyntaxNode,input, index...(index + 10))
                                        @index += 10
                                      else
                                        terminal_parse_failure("supertrib ")
                                        r18 = nil
                                      end
                                      if r18
                                        r0 = r18
                                        r0.extend(RankUninomial0)
                                      else
                                        @index = i0
                                        r0 = nil
                                      end
                                    end
                                  end
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end

    node_cache[:rank_uninomial][start_index] = r0

    r0
  end

  module Species0
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module Species1
    def value
      a.value + " " + b.value
    end

    def canonical
      a.canonical
    end

    def hybrid
      a.hybrid rescue false
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      {:species => a.details[:species].merge(b.details)}
    end
  end

  def _nt_species
    start_index = index
    if node_cache[:species].has_key?(index)
      cached = node_cache[:species][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_species_string
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_authorship
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Species0)
      r1.extend(Species1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r5 = _nt_species_string
      if r5
        r0 = r5
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:species][start_index] = r0

    r0
  end

  module SpeciesString0
    def canonical
      value
    end

    def pos
      {interval.begin => ["species", interval.end]}
    end

    def hybrid
      false
    end

    def details
      {:species => {:string => value}}
    end
  end

  def _nt_species_string
    start_index = index
    if node_cache[:species_string].has_key?(index)
      cached = node_cache[:species_string][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_species_word
    r1.extend(SpeciesString0)
    if r1
      r0 = r1
    else
      r2 = _nt_species_word_hybrid
      if r2
        r0 = r2
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:species_string][start_index] = r0

    r0
  end

  module Infragenus0
    def left_paren
      elements[0]
    end

    def space1
      elements[1]
    end

    def a
      elements[2]
    end

    def space2
      elements[3]
    end

    def right_paren
      elements[4]
    end
  end

  module Infragenus1
    def value
      "(" + a.value + ")"
    end

    def canonical
      a.value
    end

    def pos
      {a.interval.begin => ["infragenus", a.interval.end]}
    end

    def details
      {:infragenus => {:string => a.value}}
    end
  end

  def _nt_infragenus
    start_index = index
    if node_cache[:infragenus].has_key?(index)
      cached = node_cache[:infragenus][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_left_paren
    s0 << r1
    if r1
      r2 = _nt_space
      s0 << r2
      if r2
        i3 = index
        r4 = _nt_cap_latin_word
        if r4
          r3 = r4
        else
          r5 = _nt_capped_dotted_char
          if r5
            r3 = r5
          else
            @index = i3
            r3 = nil
          end
        end
        s0 << r3
        if r3
          r6 = _nt_space
          s0 << r6
          if r6
            r7 = _nt_right_paren
            s0 << r7
          end
        end
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(Infragenus0)
      r0.extend(Infragenus1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:infragenus][start_index] = r0

    r0
  end

  module Genus0
    def space_hard1
      elements[0]
    end

    def author_prefix_word
      elements[1]
    end

    def space_hard2
      elements[2]
    end

    def author_word
      elements[3]
    end
  end

  module Genus1
    def a
      elements[0]
    end

  end

  module Genus2
    def value
      a.value
    end

    def pos
      {a.interval.begin => ["genus", a.interval.end]}
    end

    def canonical
      a.value
    end

    def details
      {:genus => {:string => a.value}}
    end
  end

  def _nt_genus
    start_index = index
    if node_cache[:genus].has_key?(index)
      cached = node_cache[:genus][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    i1 = index
    r2 = _nt_abbreviated_genus
    if r2
      r1 = r2
    else
      r3 = _nt_uninomial_string
      if r3
        r1 = r3
      else
        @index = i1
        r1 = nil
      end
    end
    s0 << r1
    if r1
      i4 = index
      i5, s5 = index, []
      r6 = _nt_space_hard
      s5 << r6
      if r6
        r7 = _nt_author_prefix_word
        s5 << r7
        if r7
          r8 = _nt_space_hard
          s5 << r8
          if r8
            r9 = _nt_author_word
            s5 << r9
          end
        end
      end
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(Genus0)
      else
        @index = i5
        r5 = nil
      end
      if r5
        r4 = nil
      else
        @index = i4
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(Genus1)
      r0.extend(Genus2)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:genus][start_index] = r0

    r0
  end

  module AbbreviatedGenus0
    def space
      elements[4]
    end
  end

  module AbbreviatedGenus1
    def value
      text_value.strip
    end

    def canonical
      value
    end

    def pos
      {interval.begin => ["abbreviated_genus", interval.end]}
    end

    def details
      {:abbreviated_genus => {:string => value}}
    end
  end

  def _nt_abbreviated_genus
    start_index = index
    if node_cache[:abbreviated_genus].has_key?(index)
      cached = node_cache[:abbreviated_genus][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    if has_terminal?('\G[A-Z]', true, index)
      r1 = true
      @index += 1
    else
      r1 = nil
    end
    s0 << r1
    if r1
      if has_terminal?('\G[a-z]', true, index)
        r3 = true
        @index += 1
      else
        r3 = nil
      end
      if r3
        r2 = r3
      else
        r2 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r2
      if r2
        if has_terminal?('\G[a-z]', true, index)
          r5 = true
          @index += 1
        else
          r5 = nil
        end
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
        if r4
          if has_terminal?('\G[\\\\.]', true, index)
            r6 = true
            @index += 1
          else
            r6 = nil
          end
          s0 << r6
          if r6
            r7 = _nt_space
            s0 << r7
          end
        end
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(AbbreviatedGenus0)
      r0.extend(AbbreviatedGenus1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:abbreviated_genus][start_index] = r0

    r0
  end

  module UninomialName0
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def b
      elements[2]
    end

    def space2
      elements[3]
    end

    def c
      elements[4]
    end
  end

  module UninomialName1
    def value
      a.value + " " + b.value + " " + c.value
    end

    def canonical
      a.canonical
    end

    def pos
      a.pos.merge(b.pos).merge(c.pos)
    end

    def hybrid
      false
    end

    def details
      {:uninomial => a.details[:uninomial].merge(b.details).merge(c.details)}
    end
  end

  module UninomialName2
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module UninomialName3
    def value
      a.value + " " + b.value
    end

    def canonical
      a.canonical
    end

    def pos
      a.pos.merge(b.pos)
    end

    def hybrid
      false
    end

    def details
      {:uninomial => a.details[:uninomial].merge(b.details)}
    end
  end

  module UninomialName4
    def a
      elements[0]
    end

    def space_hard
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module UninomialName5
    def value
      a.value + " " + b.value
    end

    def canonical
      a.canonical
    end

    def pos
      a.pos.merge(b.pos)
    end

    def hybrid
      false
    end

    def details
      {:uninomial => a.details[:uninomial].merge(b.details)}
    end
  end

  def _nt_uninomial_name
    start_index = index
    if node_cache[:uninomial_name].has_key?(index)
      cached = node_cache[:uninomial_name][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_uninomial_string
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_infragenus
        s1 << r4
        if r4
          r5 = _nt_space
          s1 << r5
          if r5
            r6 = _nt_simple_authorship
            s1 << r6
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(UninomialName0)
      r1.extend(UninomialName1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i7, s7 = index, []
      r8 = _nt_uninomial_string
      s7 << r8
      if r8
        r9 = _nt_space
        s7 << r9
        if r9
          r10 = _nt_infragenus
          s7 << r10
        end
      end
      if s7.last
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        r7.extend(UninomialName2)
        r7.extend(UninomialName3)
      else
        @index = i7
        r7 = nil
      end
      if r7
        r0 = r7
      else
        i11, s11 = index, []
        r12 = _nt_uninomial_string
        s11 << r12
        if r12
          r13 = _nt_space_hard
          s11 << r13
          if r13
            r14 = _nt_authorship
            s11 << r14
          end
        end
        if s11.last
          r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
          r11.extend(UninomialName4)
          r11.extend(UninomialName5)
        else
          @index = i11
          r11 = nil
        end
        if r11
          r0 = r11
        else
          r15 = _nt_uninomial_string
          if r15
            r0 = r15
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end

    node_cache[:uninomial_name][start_index] = r0

    r0
  end

  module UninomialString0
    def canonical
      value
    end

    def pos
      {interval.begin => ["uninomial", interval.end]}
    end

    def hybrid
      false
    end

    def details
      {:uninomial => {:string => value}}
    end
  end

  def _nt_uninomial_string
    start_index = index
    if node_cache[:uninomial_string].has_key?(index)
      cached = node_cache[:uninomial_string][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_cap_latin_word_pair
    if r1
      r0 = r1
      r0.extend(UninomialString0)
    else
      r2 = _nt_cap_latin_word
      if r2
        r0 = r2
        r0.extend(UninomialString0)
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:uninomial_string][start_index] = r0

    r0
  end

  module Authorship0
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def b
      elements[2]
    end

    def space2
      elements[4]
    end

    def c
      elements[5]
    end
  end

  module Authorship1
    def value
      a.value + " " + b.value + " " + c.value
    end

    def pos
      a.pos.merge(b.pos).merge(c.pos)
    end

    def details
      val = {:authorship => text_value.strip, :combinationAuthorTeam => b.details[:basionymAuthorTeam], :basionymAuthorTeam => a.details[:basionymAuthorTeam]}
      val[:combinationAuthorTeam].merge!(c.details)
      val
    end
  end

  module Authorship2
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module Authorship3
    def value
      a.value + " " + b.value
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      {:authorship => text_value.strip, :combinationAuthorTeam => b.details[:basionymAuthorTeam], :basionymAuthorTeam => a.details[:basionymAuthorTeam]}
    end
  end

  module Authorship4
    def a
      elements[0]
    end

    def space
      elements[2]
    end

    def b
      elements[3]
    end
  end

  module Authorship5
    def value
      a.value + " " + b.value
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      val = a.details
      val[:authorship] = text_value.strip
      val[:basionymAuthorTeam].merge!(b.details)
      val
    end
  end

  def _nt_authorship
    start_index = index
    if node_cache[:authorship].has_key?(index)
      cached = node_cache[:authorship][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_basionym_authorship_with_parenthesis
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_simple_authorship
        s1 << r4
        if r4
          if has_terminal?(",", false, index)
            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(",")
            r6 = nil
          end
          if r6
            r5 = r6
          else
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s1 << r5
          if r5
            r7 = _nt_space
            s1 << r7
            if r7
              r8 = _nt_ex_authorship
              s1 << r8
            end
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Authorship0)
      r1.extend(Authorship1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i9, s9 = index, []
      r10 = _nt_basionym_authorship_with_parenthesis
      s9 << r10
      if r10
        r11 = _nt_space
        s9 << r11
        if r11
          r12 = _nt_simple_authorship
          s9 << r12
        end
      end
      if s9.last
        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
        r9.extend(Authorship2)
        r9.extend(Authorship3)
      else
        @index = i9
        r9 = nil
      end
      if r9
        r0 = r9
      else
        r13 = _nt_basionym_authorship_with_parenthesis
        if r13
          r0 = r13
        else
          i14, s14 = index, []
          r15 = _nt_simple_authorship
          s14 << r15
          if r15
            if has_terminal?(",", false, index)
              r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure(",")
              r17 = nil
            end
            if r17
              r16 = r17
            else
              r16 = instantiate_node(SyntaxNode,input, index...index)
            end
            s14 << r16
            if r16
              r18 = _nt_space
              s14 << r18
              if r18
                r19 = _nt_ex_authorship
                s14 << r19
              end
            end
          end
          if s14.last
            r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
            r14.extend(Authorship4)
            r14.extend(Authorship5)
          else
            @index = i14
            r14 = nil
          end
          if r14
            r0 = r14
          else
            r20 = _nt_simple_authorship
            if r20
              r0 = r20
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end

    node_cache[:authorship][start_index] = r0

    r0
  end

  module BasionymAuthorshipWithParenthesis0
    def left_paren
      elements[0]
    end

    def space1
      elements[1]
    end

    def a
      elements[2]
    end

    def space2
      elements[3]
    end

    def right_paren
      elements[4]
    end

    def space3
      elements[5]
    end

    def space4
      elements[7]
    end

    def b
      elements[8]
    end
  end

  module BasionymAuthorshipWithParenthesis1
    def value
      "(" + a.value + " " + b.value + ")"
    end

    def pos
     a.pos.merge(b.pos)
    end

    def details
      { :authorship => text_value,
        :basionymAuthorTeam => {:author_team => text_value}.merge(a.details).merge(b.details)
        }
    end
  end

  module BasionymAuthorshipWithParenthesis2
    def left_paren
      elements[0]
    end

    def space1
      elements[1]
    end

    def a
      elements[2]
    end

    def space2
      elements[4]
    end

    def b
      elements[5]
    end

    def space3
      elements[6]
    end

    def right_paren
      elements[7]
    end
  end

  module BasionymAuthorshipWithParenthesis3
    def value
      "(" + a.value + " " + b.value + ")"
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      val = a.details
      val[:basionymAuthorTeam].merge!(b.details)
      val[:authorship] = text_value.strip
      val
    end
  end

  module BasionymAuthorshipWithParenthesis4
    def left_paren
      elements[0]
    end

    def space1
      elements[1]
    end

    def a
      elements[2]
    end

    def space2
      elements[3]
    end

    def right_paren
      elements[4]
    end
  end

  module BasionymAuthorshipWithParenthesis5
    def value
      "(" + a.value + ")"
    end

    def pos
      a.pos
    end

    def details
      val = a.details
      val[:authorship] = text_value
      val
    end
  end

  module BasionymAuthorshipWithParenthesis6
    def left_paren
      elements[0]
    end

    def space1
      elements[1]
    end

    def a
      elements[2]
    end

    def space2
      elements[3]
    end

    def right_paren
      elements[4]
    end
  end

  module BasionymAuthorshipWithParenthesis7
    def value
      "(?)"
    end

    def pos
      {a.interval.begin => ["unknown_author", a.interval.end]}
    end

    def details
      {:authorship => text_value, :basionymAuthorTeam => {:authorTeam => text_value, :author => ["?"]}}
    end
  end

  def _nt_basionym_authorship_with_parenthesis
    start_index = index
    if node_cache[:basionym_authorship_with_parenthesis].has_key?(index)
      cached = node_cache[:basionym_authorship_with_parenthesis][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_left_paren
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_authors_names
        s1 << r4
        if r4
          r5 = _nt_space
          s1 << r5
          if r5
            r6 = _nt_right_paren
            s1 << r6
            if r6
              r7 = _nt_space
              s1 << r7
              if r7
                if has_terminal?('\G[,]', true, index)
                  r9 = true
                  @index += 1
                else
                  r9 = nil
                end
                if r9
                  r8 = r9
                else
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s1 << r8
                if r8
                  r10 = _nt_space
                  s1 << r10
                  if r10
                    r11 = _nt_year
                    s1 << r11
                  end
                end
              end
            end
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(BasionymAuthorshipWithParenthesis0)
      r1.extend(BasionymAuthorshipWithParenthesis1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i12, s12 = index, []
      r13 = _nt_left_paren
      s12 << r13
      if r13
        r14 = _nt_space
        s12 << r14
        if r14
          r15 = _nt_simple_authorship
          s12 << r15
          if r15
            if has_terminal?(",", false, index)
              r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure(",")
              r17 = nil
            end
            if r17
              r16 = r17
            else
              r16 = instantiate_node(SyntaxNode,input, index...index)
            end
            s12 << r16
            if r16
              r18 = _nt_space
              s12 << r18
              if r18
                r19 = _nt_ex_authorship
                s12 << r19
                if r19
                  r20 = _nt_space
                  s12 << r20
                  if r20
                    r21 = _nt_right_paren
                    s12 << r21
                  end
                end
              end
            end
          end
        end
      end
      if s12.last
        r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
        r12.extend(BasionymAuthorshipWithParenthesis2)
        r12.extend(BasionymAuthorshipWithParenthesis3)
      else
        @index = i12
        r12 = nil
      end
      if r12
        r0 = r12
      else
        i22, s22 = index, []
        r23 = _nt_left_paren
        s22 << r23
        if r23
          r24 = _nt_space
          s22 << r24
          if r24
            r25 = _nt_simple_authorship
            s22 << r25
            if r25
              r26 = _nt_space
              s22 << r26
              if r26
                r27 = _nt_right_paren
                s22 << r27
              end
            end
          end
        end
        if s22.last
          r22 = instantiate_node(SyntaxNode,input, i22...index, s22)
          r22.extend(BasionymAuthorshipWithParenthesis4)
          r22.extend(BasionymAuthorshipWithParenthesis5)
        else
          @index = i22
          r22 = nil
        end
        if r22
          r0 = r22
        else
          i28, s28 = index, []
          r29 = _nt_left_paren
          s28 << r29
          if r29
            r30 = _nt_space
            s28 << r30
            if r30
              if has_terminal?("?", false, index)
                r31 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure("?")
                r31 = nil
              end
              s28 << r31
              if r31
                r32 = _nt_space
                s28 << r32
                if r32
                  r33 = _nt_right_paren
                  s28 << r33
                end
              end
            end
          end
          if s28.last
            r28 = instantiate_node(SyntaxNode,input, i28...index, s28)
            r28.extend(BasionymAuthorshipWithParenthesis6)
            r28.extend(BasionymAuthorshipWithParenthesis7)
          else
            @index = i28
            r28 = nil
          end
          if r28
            r0 = r28
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end

    node_cache[:basionym_authorship_with_parenthesis][start_index] = r0

    r0
  end

  module ExAuthorship0
    def ex_sep
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module ExAuthorship1
    def value
      " ex " + b.value
    end

    def pos
      b.pos
    end

    def details
      val = {:exAuthorTeam => {:authorTeam => b.text_value.strip}.merge(b.details[:basionymAuthorTeam])}
      val
    end
  end

  def _nt_ex_authorship
    start_index = index
    if node_cache[:ex_authorship].has_key?(index)
      cached = node_cache[:ex_authorship][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_ex_sep
    s0 << r1
    if r1
      r2 = _nt_space
      s0 << r2
      if r2
        r3 = _nt_simple_authorship
        s0 << r3
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(ExAuthorship0)
      r0.extend(ExAuthorship1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:ex_authorship][start_index] = r0

    r0
  end

  module SimpleAuthorship0
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def space2
      elements[3]
    end

    def b
      elements[4]
    end

    def space3
      elements[6]
    end

    def space4
      elements[8]
    end

    def authors_names
      elements[9]
    end

    def space5
      elements[10]
    end

    def space6
      elements[12]
    end

    def year
      elements[13]
    end
  end

  module SimpleAuthorship1
    def value
      a.value + " " + b.value
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      details_with_arg(:basionymAuthorTeam)
    end

    def details_with_arg(authorTeamType = "basionymAuthorTeam")
      { :authorship => text_value,
        authorTeamType.to_sym => {
          :authorTeam => a.text_value.strip
        }.merge(a.details).merge(b.details)
      }
    end
  end

  module SimpleAuthorship2
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def space2
      elements[3]
    end

    def b
      elements[4]
    end
  end

  module SimpleAuthorship3
    def value
      a.value + " " + b.value
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      details_with_arg(:basionymAuthorTeam)
    end

    def details_with_arg(authorTeamType = "basionymAuthorTeam")
      { :authorship => text_value,
        authorTeamType.to_sym => {
          :authorTeam => a.text_value.strip
        }.merge(a.details).merge(b.details)
      }
    end
  end

  module SimpleAuthorship4
    def details
      details = details_with_arg(:basionymAuthorTeam)
      details[:basionymAuthorTeam].merge!(super)
      details
    end

    def details_with_arg(authorTeamType = "basionymAuthorTeam")
      { :authorship => text_value,
        authorTeamType.to_sym => {
          :authorTeam => text_value,
        }
      }
    end
  end

  def _nt_simple_authorship
    start_index = index
    if node_cache[:simple_authorship].has_key?(index)
      cached = node_cache[:simple_authorship][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_authors_names
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        if has_terminal?('\G[,]', true, index)
          r5 = true
          @index += 1
        else
          r5 = nil
        end
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s1 << r4
        if r4
          r6 = _nt_space
          s1 << r6
          if r6
            r8 = _nt_year
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s1 << r7
            if r7
              if has_terminal?('\G[,]', true, index)
                r10 = true
                @index += 1
              else
                r10 = nil
              end
              if r10
                r9 = r10
              else
                r9 = instantiate_node(SyntaxNode,input, index...index)
              end
              s1 << r9
              if r9
                r11 = _nt_space
                s1 << r11
                if r11
                  if has_terminal?("non", false, index)
                    r12 = instantiate_node(SyntaxNode,input, index...(index + 3))
                    @index += 3
                  else
                    terminal_parse_failure("non")
                    r12 = nil
                  end
                  s1 << r12
                  if r12
                    r13 = _nt_space
                    s1 << r13
                    if r13
                      r14 = _nt_authors_names
                      s1 << r14
                      if r14
                        r15 = _nt_space
                        s1 << r15
                        if r15
                          if has_terminal?('\G[,]', true, index)
                            r17 = true
                            @index += 1
                          else
                            r17 = nil
                          end
                          if r17
                            r16 = r17
                          else
                            r16 = instantiate_node(SyntaxNode,input, index...index)
                          end
                          s1 << r16
                          if r16
                            r18 = _nt_space
                            s1 << r18
                            if r18
                              r19 = _nt_year
                              s1 << r19
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(SimpleAuthorship0)
      r1.extend(SimpleAuthorship1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i20, s20 = index, []
      r21 = _nt_authors_names
      s20 << r21
      if r21
        r22 = _nt_space
        s20 << r22
        if r22
          if has_terminal?('\G[,]', true, index)
            r24 = true
            @index += 1
          else
            r24 = nil
          end
          if r24
            r23 = r24
          else
            r23 = instantiate_node(SyntaxNode,input, index...index)
          end
          s20 << r23
          if r23
            r25 = _nt_space
            s20 << r25
            if r25
              r26 = _nt_year
              s20 << r26
            end
          end
        end
      end
      if s20.last
        r20 = instantiate_node(SyntaxNode,input, i20...index, s20)
        r20.extend(SimpleAuthorship2)
        r20.extend(SimpleAuthorship3)
      else
        @index = i20
        r20 = nil
      end
      if r20
        r0 = r20
      else
        r27 = _nt_authors_names
        r27.extend(SimpleAuthorship4)
        if r27
          r0 = r27
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:simple_authorship][start_index] = r0

    r0
  end

  module AuthorsNames0
    def a
      elements[0]
    end

    def space1
      elements[1]
    end

    def sep
      elements[2]
    end

    def space2
      elements[3]
    end

    def b
      elements[4]
    end
  end

  module AuthorsNames1
    def value
      sep.apply(a,b)
    end

    def pos
      sep.pos(a,b)
    end

    def details
      sep.details(a,b)
    end
  end

  def _nt_authors_names
    start_index = index
    if node_cache[:authors_names].has_key?(index)
      cached = node_cache[:authors_names][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_author_name
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_author_separator
        s1 << r4
        if r4
          r5 = _nt_space
          s1 << r5
          if r5
            r6 = _nt_authors_names
            s1 << r6
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(AuthorsNames0)
      r1.extend(AuthorsNames1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r7 = _nt_author_name
      if r7
        r0 = r7
      else
        r8 = _nt_unknown_auth
        if r8
          r0 = r8
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:authors_names][start_index] = r0

    r0
  end

  module UnknownAuth0
  end

  module UnknownAuth1
    def value
      text_value
    end

    def pos
     {interval.begin => ["unknown_author", interval.end]}
    end

    def details
      {:author => ["unknown"]}
    end
  end

  def _nt_unknown_auth
    start_index = index
    if node_cache[:unknown_auth].has_key?(index)
      cached = node_cache[:unknown_auth][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    i1 = index
    if has_terminal?("auct.", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 5))
      @index += 5
    else
      terminal_parse_failure("auct.")
      r2 = nil
    end
    if r2
      r1 = r2
    else
      if has_terminal?("auct", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 4))
        @index += 4
      else
        terminal_parse_failure("auct")
        r3 = nil
      end
      if r3
        r1 = r3
      else
        if has_terminal?("hort.", false, index)
          r4 = instantiate_node(SyntaxNode,input, index...(index + 5))
          @index += 5
        else
          terminal_parse_failure("hort.")
          r4 = nil
        end
        if r4
          r1 = r4
        else
          if has_terminal?("hort", false, index)
            r5 = instantiate_node(SyntaxNode,input, index...(index + 4))
            @index += 4
          else
            terminal_parse_failure("hort")
            r5 = nil
          end
          if r5
            r1 = r5
          else
            if has_terminal?("anon.", false, index)
              r6 = instantiate_node(SyntaxNode,input, index...(index + 5))
              @index += 5
            else
              terminal_parse_failure("anon.")
              r6 = nil
            end
            if r6
              r1 = r6
            else
              if has_terminal?("anon", false, index)
                r7 = instantiate_node(SyntaxNode,input, index...(index + 4))
                @index += 4
              else
                terminal_parse_failure("anon")
                r7 = nil
              end
              if r7
                r1 = r7
              else
                if has_terminal?("ht.", false, index)
                  r8 = instantiate_node(SyntaxNode,input, index...(index + 3))
                  @index += 3
                else
                  terminal_parse_failure("ht.")
                  r8 = nil
                end
                if r8
                  r1 = r8
                else
                  if has_terminal?("ht", false, index)
                    r9 = instantiate_node(SyntaxNode,input, index...(index + 2))
                    @index += 2
                  else
                    terminal_parse_failure("ht")
                    r9 = nil
                  end
                  if r9
                    r1 = r9
                  else
                    @index = i1
                    r1 = nil
                  end
                end
              end
            end
          end
        end
      end
    end
    s0 << r1
    if r1
      i10 = index
      r11 = _nt_latin_word
      if r11
        r10 = nil
      else
        @index = i10
        r10 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r10
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(UnknownAuth0)
      r0.extend(UnknownAuth1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:unknown_auth][start_index] = r0

    r0
  end

  module ExSep0
  end

  def _nt_ex_sep
    start_index = index
    if node_cache[:ex_sep].has_key?(index)
      cached = node_cache[:ex_sep][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    i1 = index
    if has_terminal?("ex", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
      @index += 2
    else
      terminal_parse_failure("ex")
      r2 = nil
    end
    if r2
      r1 = r2
    else
      if has_terminal?("in", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure("in")
        r3 = nil
      end
      if r3
        r1 = r3
      else
        @index = i1
        r1 = nil
      end
    end
    s0 << r1
    if r1
      i4 = index
      if has_terminal?('\G[\\s]', true, index)
        r5 = true
        @index += 1
      else
        r5 = nil
      end
      if r5
        @index = i4
        r4 = instantiate_node(SyntaxNode,input, index...index)
      else
        r4 = nil
      end
      s0 << r4
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(ExSep0)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:ex_sep][start_index] = r0

    r0
  end

  module AuthorSeparator0
    def apply(a,b)
      sep = text_value.strip
      sep = " &" if ["&amp;", "&","and","et"].include? sep
      a.value + sep + " " + b.value
    end

    def pos(a,b)
      a.pos.merge(b.pos)
    end

    def details(a,b)
      {:author => a.details[:author] + b.details[:author]}
    end
  end

  def _nt_author_separator
    start_index = index
    if node_cache[:author_separator].has_key?(index)
      cached = node_cache[:author_separator][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    if has_terminal?("&amp;", false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 5))
      @index += 5
    else
      terminal_parse_failure("&amp;")
      r1 = nil
    end
    if r1
      r0 = r1
      r0.extend(AuthorSeparator0)
    else
      if has_terminal?("&", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("&")
        r2 = nil
      end
      if r2
        r0 = r2
        r0.extend(AuthorSeparator0)
      else
        if has_terminal?(",", false, index)
          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure(",")
          r3 = nil
        end
        if r3
          r0 = r3
          r0.extend(AuthorSeparator0)
        else
          if has_terminal?("and", false, index)
            r4 = instantiate_node(SyntaxNode,input, index...(index + 3))
            @index += 3
          else
            terminal_parse_failure("and")
            r4 = nil
          end
          if r4
            r0 = r4
            r0.extend(AuthorSeparator0)
          else
            if has_terminal?("et", false, index)
              r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
              @index += 2
            else
              terminal_parse_failure("et")
              r5 = nil
            end
            if r5
              r0 = r5
              r0.extend(AuthorSeparator0)
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end

    node_cache[:author_separator][start_index] = r0

    r0
  end

  module AuthorName0
    def space1
      elements[0]
    end

    def a
      elements[1]
    end

    def space2
      elements[2]
    end

    def b
      elements[3]
    end

    def space3
      elements[4]
    end

  end

  module AuthorName1
    def value
      a.value + " " + b.value
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      {:author => [value]}
    end
  end

  def _nt_author_name
    start_index = index
    if node_cache[:author_name].has_key?(index)
      cached = node_cache[:author_name][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_space
    s1 << r2
    if r2
      r3 = _nt_author_name_without_postfix
      s1 << r3
      if r3
        r4 = _nt_space
        s1 << r4
        if r4
          r5 = _nt_author_postfix_word
          s1 << r5
          if r5
            r6 = _nt_space
            s1 << r6
            if r6
              i7 = index
              r8 = _nt_latin_word
              if r8
                r7 = nil
              else
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s1 << r7
            end
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(AuthorName0)
      r1.extend(AuthorName1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r9 = _nt_author_name_without_postfix
      if r9
        r0 = r9
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:author_name][start_index] = r0

    r0
  end

  module AuthorNameWithoutPostfix0
    def space1
      elements[0]
    end

    def a
      elements[1]
    end

    def space2
      elements[2]
    end

    def b
      elements[3]
    end
  end

  module AuthorNameWithoutPostfix1
    def value
      a.value + " " + b.value
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      {:author => [value]}
    end
  end

  module AuthorNameWithoutPostfix2
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module AuthorNameWithoutPostfix3
    def value
      a.value + " " + b.value
    end

    def pos
      a.pos.merge(b.pos)
    end

    def details
      {:author => [value]}
    end
  end

  def _nt_author_name_without_postfix
    start_index = index
    if node_cache[:author_name_without_postfix].has_key?(index)
      cached = node_cache[:author_name_without_postfix][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_space
    s1 << r2
    if r2
      r3 = _nt_author_prefix_word
      s1 << r3
      if r3
        r4 = _nt_space
        s1 << r4
        if r4
          r5 = _nt_author_name
          s1 << r5
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(AuthorNameWithoutPostfix0)
      r1.extend(AuthorNameWithoutPostfix1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i6, s6 = index, []
      r7 = _nt_author_word
      s6 << r7
      if r7
        r8 = _nt_space
        s6 << r8
        if r8
          r9 = _nt_author_name
          s6 << r9
        end
      end
      if s6.last
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        r6.extend(AuthorNameWithoutPostfix2)
        r6.extend(AuthorNameWithoutPostfix3)
      else
        @index = i6
        r6 = nil
      end
      if r6
        r0 = r6
      else
        r10 = _nt_author_word
        if r10
          r0 = r10
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:author_name_without_postfix][start_index] = r0

    r0
  end

  module AuthorWord0
    def value
      text_value.strip
    end

    def pos
      {interval.begin => ["author_word", 1], (interval.begin + 2) => ["author_word", 2], (interval.begin + 5) => ["author_word", 2]}
    end

    def details
      {:author => [value]}
    end
  end

  module AuthorWord1
    def value
      text_value.strip
    end

    def pos
      #cheating because there are several words in some of them
      {interval.begin => ["author_word", interval.end]}
    end

    def details
      {:author => [value]}
    end
  end

  module AuthorWord2
  end

  module AuthorWord3
    def value
      text_value.gsub(/([\p{Lu}]{3,})/) do |match|
        UnicodeUtils.titlecase(match)
      end
    end

    def pos
      {interval.begin => ["author_word", interval.end]}
    end

    def details
      {:author => [value]}
    end
  end

  module AuthorWord4
  end

  module AuthorWord5
    def value
      text_value
    end

    def pos
      {interval.begin => ["author_word", interval.end]}
    end

    def details
      {:author => [value]}
    end
  end

  def _nt_author_word
    start_index = index
    if node_cache[:author_word].has_key?(index)
      cached = node_cache[:author_word][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    if has_terminal?("A S. Xu", false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
      r1.extend(AuthorWord0)
      @index += 7
    else
      terminal_parse_failure("A S. Xu")
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i2 = index
      if has_terminal?("arg.", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 4))
        @index += 4
      else
        terminal_parse_failure("arg.")
        r3 = nil
      end
      if r3
        r2 = r3
        r2.extend(AuthorWord1)
      else
        if has_terminal?("et al.\{\?\}", false, index)
          r4 = instantiate_node(SyntaxNode,input, index...(index + 9))
          @index += 9
        else
          terminal_parse_failure("et al.\{\?\}")
          r4 = nil
        end
        if r4
          r2 = r4
          r2.extend(AuthorWord1)
        else
          if has_terminal?("et al.", false, index)
            r5 = instantiate_node(SyntaxNode,input, index...(index + 6))
            @index += 6
          else
            terminal_parse_failure("et al.")
            r5 = nil
          end
          if r5
            r2 = r5
            r2.extend(AuthorWord1)
          else
            if has_terminal?("et al", false, index)
              r6 = instantiate_node(SyntaxNode,input, index...(index + 5))
              @index += 5
            else
              terminal_parse_failure("et al")
              r6 = nil
            end
            if r6
              r2 = r6
              r2.extend(AuthorWord1)
            else
              @index = i2
              r2 = nil
            end
          end
        end
      end
      if r2
        r0 = r2
      else
        i7, s7 = index, []
        i8 = index
        if has_terminal?("Å", false, index)
          r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure("Å")
          r9 = nil
        end
        if r9
          r8 = r9
        else
          if has_terminal?("Ö", false, index)
            r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure("Ö")
            r10 = nil
          end
          if r10
            r8 = r10
          else
            if has_terminal?("Á", false, index)
              r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure("Á")
              r11 = nil
            end
            if r11
              r8 = r11
            else
              if has_terminal?("Ø", false, index)
                r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure("Ø")
                r12 = nil
              end
              if r12
                r8 = r12
              else
                if has_terminal?("Ô", false, index)
                  r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
                  @index += 1
                else
                  terminal_parse_failure("Ô")
                  r13 = nil
                end
                if r13
                  r8 = r13
                else
                  if has_terminal?("Š", false, index)
                    r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
                    @index += 1
                  else
                    terminal_parse_failure("Š")
                    r14 = nil
                  end
                  if r14
                    r8 = r14
                  else
                    if has_terminal?("Ś", false, index)
                      r15 = instantiate_node(SyntaxNode,input, index...(index + 1))
                      @index += 1
                    else
                      terminal_parse_failure("Ś")
                      r15 = nil
                    end
                    if r15
                      r8 = r15
                    else
                      if has_terminal?("Č", false, index)
                        r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
                        @index += 1
                      else
                        terminal_parse_failure("Č")
                        r16 = nil
                      end
                      if r16
                        r8 = r16
                      else
                        if has_terminal?("Ķ", false, index)
                          r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
                          @index += 1
                        else
                          terminal_parse_failure("Ķ")
                          r17 = nil
                        end
                        if r17
                          r8 = r17
                        else
                          if has_terminal?("Ł", false, index)
                            r18 = instantiate_node(SyntaxNode,input, index...(index + 1))
                            @index += 1
                          else
                            terminal_parse_failure("Ł")
                            r18 = nil
                          end
                          if r18
                            r8 = r18
                          else
                            if has_terminal?("É", false, index)
                              r19 = instantiate_node(SyntaxNode,input, index...(index + 1))
                              @index += 1
                            else
                              terminal_parse_failure("É")
                              r19 = nil
                            end
                            if r19
                              r8 = r19
                            else
                              if has_terminal?("Ž", false, index)
                                r20 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                @index += 1
                              else
                                terminal_parse_failure("Ž")
                                r20 = nil
                              end
                              if r20
                                r8 = r20
                              else
                                if has_terminal?('\G[A-W]', true, index)
                                  r21 = true
                                  @index += 1
                                else
                                  r21 = nil
                                end
                                if r21
                                  r8 = r21
                                else
                                  if has_terminal?('\G[Y-Z]', true, index)
                                    r22 = true
                                    @index += 1
                                  else
                                    r22 = nil
                                  end
                                  if r22
                                    r8 = r22
                                  else
                                    @index = i8
                                    r8 = nil
                                  end
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
        s7 << r8
        if r8
          s23, i23 = [], index
          loop do
            if has_terminal?('\G[^0-9\\[\\]\\(\\)\\s&,]', true, index)
              r24 = true
              @index += 1
            else
              r24 = nil
            end
            if r24
              s23 << r24
            else
              break
            end
          end
          r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
          s7 << r23
        end
        if s7.last
          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
          r7.extend(AuthorWord2)
          r7.extend(AuthorWord3)
        else
          @index = i7
          r7 = nil
        end
        if r7
          r0 = r7
        else
          i25, s25 = index, []
          if has_terminal?("X", false, index)
            r26 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure("X")
            r26 = nil
          end
          s25 << r26
          if r26
            s27, i27 = [], index
            loop do
              if has_terminal?('\G[^0-9\\[\\]\\(\\)\\s&,]', true, index)
                r28 = true
                @index += 1
              else
                r28 = nil
              end
              if r28
                s27 << r28
              else
                break
              end
            end
            if s27.empty?
              @index = i27
              r27 = nil
            else
              r27 = instantiate_node(SyntaxNode,input, i27...index, s27)
            end
            s25 << r27
          end
          if s25.last
            r25 = instantiate_node(SyntaxNode,input, i25...index, s25)
            r25.extend(AuthorWord4)
            r25.extend(AuthorWord5)
          else
            @index = i25
            r25 = nil
          end
          if r25
            r0 = r25
          else
            r29 = _nt_author_prefix_word
            if r29
              r0 = r29
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end

    node_cache[:author_word][start_index] = r0

    r0
  end

  module AuthorPrefixWord0
    def space
      elements[0]
    end

  end

  module AuthorPrefixWord1
    def value
      text_value
    end

    def pos
      #cheating because there are several words in some of them
      {interval.begin => ["author_word", interval.end]}
    end
  end

  def _nt_author_prefix_word
    start_index = index
    if node_cache[:author_prefix_word].has_key?(index)
      cached = node_cache[:author_prefix_word][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_space
    s0 << r1
    if r1
      i2 = index
      if has_terminal?("ab", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure("ab")
        r3 = nil
      end
      if r3
        r2 = r3
      else
        if has_terminal?("af", false, index)
          r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
          @index += 2
        else
          terminal_parse_failure("af")
          r4 = nil
        end
        if r4
          r2 = r4
        else
          if has_terminal?("bis", false, index)
            r5 = instantiate_node(SyntaxNode,input, index...(index + 3))
            @index += 3
          else
            terminal_parse_failure("bis")
            r5 = nil
          end
          if r5
            r2 = r5
          else
            if has_terminal?("da", false, index)
              r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
              @index += 2
            else
              terminal_parse_failure("da")
              r6 = nil
            end
            if r6
              r2 = r6
            else
              if has_terminal?("der", false, index)
                r7 = instantiate_node(SyntaxNode,input, index...(index + 3))
                @index += 3
              else
                terminal_parse_failure("der")
                r7 = nil
              end
              if r7
                r2 = r7
              else
                if has_terminal?("des", false, index)
                  r8 = instantiate_node(SyntaxNode,input, index...(index + 3))
                  @index += 3
                else
                  terminal_parse_failure("des")
                  r8 = nil
                end
                if r8
                  r2 = r8
                else
                  if has_terminal?("den", false, index)
                    r9 = instantiate_node(SyntaxNode,input, index...(index + 3))
                    @index += 3
                  else
                    terminal_parse_failure("den")
                    r9 = nil
                  end
                  if r9
                    r2 = r9
                  else
                    if has_terminal?("della", false, index)
                      r10 = instantiate_node(SyntaxNode,input, index...(index + 5))
                      @index += 5
                    else
                      terminal_parse_failure("della")
                      r10 = nil
                    end
                    if r10
                      r2 = r10
                    else
                      if has_terminal?("dela", false, index)
                        r11 = instantiate_node(SyntaxNode,input, index...(index + 4))
                        @index += 4
                      else
                        terminal_parse_failure("dela")
                        r11 = nil
                      end
                      if r11
                        r2 = r11
                      else
                        if has_terminal?("de", false, index)
                          r12 = instantiate_node(SyntaxNode,input, index...(index + 2))
                          @index += 2
                        else
                          terminal_parse_failure("de")
                          r12 = nil
                        end
                        if r12
                          r2 = r12
                        else
                          if has_terminal?("di", false, index)
                            r13 = instantiate_node(SyntaxNode,input, index...(index + 2))
                            @index += 2
                          else
                            terminal_parse_failure("di")
                            r13 = nil
                          end
                          if r13
                            r2 = r13
                          else
                            if has_terminal?("du", false, index)
                              r14 = instantiate_node(SyntaxNode,input, index...(index + 2))
                              @index += 2
                            else
                              terminal_parse_failure("du")
                              r14 = nil
                            end
                            if r14
                              r2 = r14
                            else
                              if has_terminal?("la", false, index)
                                r15 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                @index += 2
                              else
                                terminal_parse_failure("la")
                                r15 = nil
                              end
                              if r15
                                r2 = r15
                              else
                                if has_terminal?("ter", false, index)
                                  r16 = instantiate_node(SyntaxNode,input, index...(index + 3))
                                  @index += 3
                                else
                                  terminal_parse_failure("ter")
                                  r16 = nil
                                end
                                if r16
                                  r2 = r16
                                else
                                  if has_terminal?("van", false, index)
                                    r17 = instantiate_node(SyntaxNode,input, index...(index + 3))
                                    @index += 3
                                  else
                                    terminal_parse_failure("van")
                                    r17 = nil
                                  end
                                  if r17
                                    r2 = r17
                                  else
                                    if has_terminal?("von", false, index)
                                      r18 = instantiate_node(SyntaxNode,input, index...(index + 3))
                                      @index += 3
                                    else
                                      terminal_parse_failure("von")
                                      r18 = nil
                                    end
                                    if r18
                                      r2 = r18
                                    else
                                      @index = i2
                                      r2 = nil
                                    end
                                  end
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
      s0 << r2
      if r2
        i19 = index
        r20 = _nt_space_hard
        if r20
          @index = i19
          r19 = instantiate_node(SyntaxNode,input, index...index)
        else
          r19 = nil
        end
        s0 << r19
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(AuthorPrefixWord0)
      r0.extend(AuthorPrefixWord1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:author_prefix_word][start_index] = r0

    r0
  end

  module AuthorPostfixWord0
    def value
      text_value.strip
    end

    def pos
      {interval.begin => ["author_word", interval.end]}
    end
  end

  def _nt_author_postfix_word
    start_index = index
    if node_cache[:author_postfix_word].has_key?(index)
      cached = node_cache[:author_postfix_word][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    if has_terminal?("f.", false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 2))
      @index += 2
    else
      terminal_parse_failure("f.")
      r1 = nil
    end
    if r1
      r0 = r1
      r0.extend(AuthorPostfixWord0)
    else
      if has_terminal?("filius", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 6))
        @index += 6
      else
        terminal_parse_failure("filius")
        r2 = nil
      end
      if r2
        r0 = r2
        r0.extend(AuthorPostfixWord0)
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:author_postfix_word][start_index] = r0

    r0
  end

  module CapLatinWordPair0
    def a
      elements[0]
    end

    def b
      elements[2]
    end
  end

  module CapLatinWordPair1
    def value
      a.value + b.value.downcase
    end
  end

  def _nt_cap_latin_word_pair
    start_index = index
    if node_cache[:cap_latin_word_pair].has_key?(index)
      cached = node_cache[:cap_latin_word_pair][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_cap_latin_word
    s0 << r1
    if r1
      if has_terminal?("-", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("-")
        r2 = nil
      end
      s0 << r2
      if r2
        r3 = _nt_cap_latin_word
        s0 << r3
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(CapLatinWordPair0)
      r0.extend(CapLatinWordPair1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:cap_latin_word_pair][start_index] = r0

    r0
  end

  module CapLatinWord0
    def a
      elements[0]
    end

    def b
      elements[1]
    end

  end

  module CapLatinWord1
    def value
      (a.value rescue a.text_value) + b.value
    end
  end

  module CapLatinWord2
    def a
      elements[0]
    end

    def b
      elements[1]
    end
  end

  module CapLatinWord3
    def value
      (a.value rescue a.text_value) + b.value
    end
  end

  module CapLatinWord4
    def a
      elements[0]
    end

    def b
      elements[1]
    end
  end

  module CapLatinWord5
    def value
      a.text_value[0..0] + "e" + b.value
    end
  end

  module CapLatinWord6
    def value
      text_value
    end
  end

  def _nt_cap_latin_word
    start_index = index
    if node_cache[:cap_latin_word].has_key?(index)
      cached = node_cache[:cap_latin_word][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    i2 = index
    if has_terminal?('\G[A-Z]', true, index)
      r3 = true
      @index += 1
    else
      r3 = nil
    end
    if r3
      r2 = r3
    else
      r4 = _nt_cap_digraph
      if r4
        r2 = r4
      else
        @index = i2
        r2 = nil
      end
    end
    s1 << r2
    if r2
      r5 = _nt_latin_word
      s1 << r5
      if r5
        if has_terminal?("?", false, index)
          r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure("?")
          r6 = nil
        end
        s1 << r6
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(CapLatinWord0)
      r1.extend(CapLatinWord1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i7, s7 = index, []
      i8 = index
      if has_terminal?('\G[A-Z]', true, index)
        r9 = true
        @index += 1
      else
        r9 = nil
      end
      if r9
        r8 = r9
      else
        r10 = _nt_cap_digraph
        if r10
          r8 = r10
        else
          @index = i8
          r8 = nil
        end
      end
      s7 << r8
      if r8
        r11 = _nt_latin_word
        s7 << r11
      end
      if s7.last
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        r7.extend(CapLatinWord2)
        r7.extend(CapLatinWord3)
      else
        @index = i7
        r7 = nil
      end
      if r7
        r0 = r7
      else
        i12, s12 = index, []
        i13 = index
        if has_terminal?("AE", false, index)
          r14 = instantiate_node(SyntaxNode,input, index...(index + 2))
          @index += 2
        else
          terminal_parse_failure("AE")
          r14 = nil
        end
        if r14
          r13 = r14
        else
          if has_terminal?("OE", false, index)
            r15 = instantiate_node(SyntaxNode,input, index...(index + 2))
            @index += 2
          else
            terminal_parse_failure("OE")
            r15 = nil
          end
          if r15
            r13 = r15
          else
            @index = i13
            r13 = nil
          end
        end
        s12 << r13
        if r13
          r16 = _nt_latin_word
          s12 << r16
        end
        if s12.last
          r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
          r12.extend(CapLatinWord4)
          r12.extend(CapLatinWord5)
        else
          @index = i12
          r12 = nil
        end
        if r12
          r0 = r12
        else
          i17 = index
          if has_terminal?("Ca", false, index)
            r18 = instantiate_node(SyntaxNode,input, index...(index + 2))
            @index += 2
          else
            terminal_parse_failure("Ca")
            r18 = nil
          end
          if r18
            r17 = r18
            r17.extend(CapLatinWord6)
          else
            if has_terminal?("Ea", false, index)
              r19 = instantiate_node(SyntaxNode,input, index...(index + 2))
              @index += 2
            else
              terminal_parse_failure("Ea")
              r19 = nil
            end
            if r19
              r17 = r19
              r17.extend(CapLatinWord6)
            else
              if has_terminal?("Ge", false, index)
                r20 = instantiate_node(SyntaxNode,input, index...(index + 2))
                @index += 2
              else
                terminal_parse_failure("Ge")
                r20 = nil
              end
              if r20
                r17 = r20
                r17.extend(CapLatinWord6)
              else
                if has_terminal?("Ia", false, index)
                  r21 = instantiate_node(SyntaxNode,input, index...(index + 2))
                  @index += 2
                else
                  terminal_parse_failure("Ia")
                  r21 = nil
                end
                if r21
                  r17 = r21
                  r17.extend(CapLatinWord6)
                else
                  if has_terminal?("Io", false, index)
                    r22 = instantiate_node(SyntaxNode,input, index...(index + 2))
                    @index += 2
                  else
                    terminal_parse_failure("Io")
                    r22 = nil
                  end
                  if r22
                    r17 = r22
                    r17.extend(CapLatinWord6)
                  else
                    if has_terminal?("Io", false, index)
                      r23 = instantiate_node(SyntaxNode,input, index...(index + 2))
                      @index += 2
                    else
                      terminal_parse_failure("Io")
                      r23 = nil
                    end
                    if r23
                      r17 = r23
                      r17.extend(CapLatinWord6)
                    else
                      if has_terminal?("Ix", false, index)
                        r24 = instantiate_node(SyntaxNode,input, index...(index + 2))
                        @index += 2
                      else
                        terminal_parse_failure("Ix")
                        r24 = nil
                      end
                      if r24
                        r17 = r24
                        r17.extend(CapLatinWord6)
                      else
                        if has_terminal?("Lo", false, index)
                          r25 = instantiate_node(SyntaxNode,input, index...(index + 2))
                          @index += 2
                        else
                          terminal_parse_failure("Lo")
                          r25 = nil
                        end
                        if r25
                          r17 = r25
                          r17.extend(CapLatinWord6)
                        else
                          if has_terminal?("Oa", false, index)
                            r26 = instantiate_node(SyntaxNode,input, index...(index + 2))
                            @index += 2
                          else
                            terminal_parse_failure("Oa")
                            r26 = nil
                          end
                          if r26
                            r17 = r26
                            r17.extend(CapLatinWord6)
                          else
                            if has_terminal?("Ra", false, index)
                              r27 = instantiate_node(SyntaxNode,input, index...(index + 2))
                              @index += 2
                            else
                              terminal_parse_failure("Ra")
                              r27 = nil
                            end
                            if r27
                              r17 = r27
                              r17.extend(CapLatinWord6)
                            else
                              if has_terminal?("Ty", false, index)
                                r28 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                @index += 2
                              else
                                terminal_parse_failure("Ty")
                                r28 = nil
                              end
                              if r28
                                r17 = r28
                                r17.extend(CapLatinWord6)
                              else
                                if has_terminal?("Ua", false, index)
                                  r29 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                  @index += 2
                                else
                                  terminal_parse_failure("Ua")
                                  r29 = nil
                                end
                                if r29
                                  r17 = r29
                                  r17.extend(CapLatinWord6)
                                else
                                  if has_terminal?("Aa", false, index)
                                    r30 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                    @index += 2
                                  else
                                    terminal_parse_failure("Aa")
                                    r30 = nil
                                  end
                                  if r30
                                    r17 = r30
                                    r17.extend(CapLatinWord6)
                                  else
                                    if has_terminal?("Ja", false, index)
                                      r31 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                      @index += 2
                                    else
                                      terminal_parse_failure("Ja")
                                      r31 = nil
                                    end
                                    if r31
                                      r17 = r31
                                      r17.extend(CapLatinWord6)
                                    else
                                      if has_terminal?("Zu", false, index)
                                        r32 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                        @index += 2
                                      else
                                        terminal_parse_failure("Zu")
                                        r32 = nil
                                      end
                                      if r32
                                        r17 = r32
                                        r17.extend(CapLatinWord6)
                                      else
                                        if has_terminal?("La", false, index)
                                          r33 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                          @index += 2
                                        else
                                          terminal_parse_failure("La")
                                          r33 = nil
                                        end
                                        if r33
                                          r17 = r33
                                          r17.extend(CapLatinWord6)
                                        else
                                          if has_terminal?("Qu", false, index)
                                            r34 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                            @index += 2
                                          else
                                            terminal_parse_failure("Qu")
                                            r34 = nil
                                          end
                                          if r34
                                            r17 = r34
                                            r17.extend(CapLatinWord6)
                                          else
                                            if has_terminal?("As", false, index)
                                              r35 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                              @index += 2
                                            else
                                              terminal_parse_failure("As")
                                              r35 = nil
                                            end
                                            if r35
                                              r17 = r35
                                              r17.extend(CapLatinWord6)
                                            else
                                              if has_terminal?("Ba", false, index)
                                                r36 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                @index += 2
                                              else
                                                terminal_parse_failure("Ba")
                                                r36 = nil
                                              end
                                              if r36
                                                r17 = r36
                                                r17.extend(CapLatinWord6)
                                              else
                                                @index = i17
                                                r17 = nil
                                              end
                                            end
                                          end
                                        end
                                      end
                                    end
                                  end
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
          if r17
            r0 = r17
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end

    node_cache[:cap_latin_word][start_index] = r0

    r0
  end

  module CappedDottedChar0
  end

  module CappedDottedChar1
    def value
      text_value
    end
  end

  def _nt_capped_dotted_char
    start_index = index
    if node_cache[:capped_dotted_char].has_key?(index)
      cached = node_cache[:capped_dotted_char][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    if has_terminal?('\G[A-Z]', true, index)
      r1 = true
      @index += 1
    else
      r1 = nil
    end
    s0 << r1
    if r1
      if has_terminal?(".", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(".")
        r2 = nil
      end
      s0 << r2
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(CappedDottedChar0)
      r0.extend(CappedDottedChar1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:capped_dotted_char][start_index] = r0

    r0
  end

  module SpeciesWordHybrid0
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module SpeciesWordHybrid1
    def value
      a.value + " " + b.value
    end

    def canonical
      b.value
    end

    def hybrid
      true
    end

    def pos
      {b.interval.begin => ["species", b.interval.end]}
    end

    def details
      {:species => {:string => b.value}}
    end
  end

  module SpeciesWordHybrid2
    def a
      elements[0]
    end

    def space
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module SpeciesWordHybrid3
    def value
      "× " + b.value
    end

    def canonical
      b.value
    end

    def hybrid
      true
    end

    def pos
      {b.interval.begin => ["species", b.interval.end]}
    end

    def details
      {:species => {:string => b.value}}
    end
  end

  module SpeciesWordHybrid4
    def a
      elements[0]
    end

    def space_hard
      elements[1]
    end

    def b
      elements[2]
    end
  end

  module SpeciesWordHybrid5
    def value
      "× " + b.value
    end

    def canonical
      b.value
    end

    def hybrid
      true
    end

    def pos
      {b.interval.begin => ["species", b.interval.end]}
    end

    def details
      {:species => {:string => b.value}}
    end
  end

  def _nt_species_word_hybrid
    start_index = index
    if node_cache[:species_word_hybrid].has_key?(index)
      cached = node_cache[:species_word_hybrid][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_multiplication_sign
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        r4 = _nt_species_word
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(SpeciesWordHybrid0)
      r1.extend(SpeciesWordHybrid1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i5, s5 = index, []
      if has_terminal?("X", false, index)
        r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("X")
        r6 = nil
      end
      s5 << r6
      if r6
        r7 = _nt_space
        s5 << r7
        if r7
          r8 = _nt_species_word
          s5 << r8
        end
      end
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(SpeciesWordHybrid2)
        r5.extend(SpeciesWordHybrid3)
      else
        @index = i5
        r5 = nil
      end
      if r5
        r0 = r5
      else
        i9, s9 = index, []
        if has_terminal?("x", false, index)
          r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure("x")
          r10 = nil
        end
        s9 << r10
        if r10
          r11 = _nt_space_hard
          s9 << r11
          if r11
            r12 = _nt_species_word
            s9 << r12
          end
        end
        if s9.last
          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
          r9.extend(SpeciesWordHybrid4)
          r9.extend(SpeciesWordHybrid5)
        else
          @index = i9
          r9 = nil
        end
        if r9
          r0 = r9
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:species_word_hybrid][start_index] = r0

    r0
  end

  module AnnotationIdentification0

    def value
      text_value.strip
    end

    def apply(sp)
      ""
    end

    def canonical(sp)
      ""
    end

    def pos(sp)
      interval_end = text_value[-1] == " " ? interval.end - 1 : interval.end
      {interval.begin => ["annotation_identification", interval.end]}
    end

    def details(sp)
      {:annotation_identification => value, :ignored => sp.details}
    end
  end

  module AnnotationIdentification1
    def value
      text_value.strip
    end

    def apply(sp)
      " " + value + " " + sp.value
    end

    def canonical(sp)
      " " + sp.canonical
    end

    def pos(sp)
      interval_end = text_value[-1] == " " ? interval.end - 1 : interval.end
      {interval.begin => ["annotation_identification", interval.end]}.merge(sp.pos)
    end

    def details(sp)
      {:annotation_identification => value, :species => sp.details}
    end
  end

  def _nt_annotation_identification
    start_index = index
    if node_cache[:annotation_identification].has_key?(index)
      cached = node_cache[:annotation_identification][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1 = index
    if has_terminal?("sp.nr.", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 6))
      @index += 6
    else
      terminal_parse_failure("sp.nr.")
      r2 = nil
    end
    if r2
      r1 = r2
      r1.extend(AnnotationIdentification0)
    else
      if has_terminal?("sp. nr.", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 7))
        @index += 7
      else
        terminal_parse_failure("sp. nr.")
        r3 = nil
      end
      if r3
        r1 = r3
        r1.extend(AnnotationIdentification0)
      else
        if has_terminal?("nr.", false, index)
          r4 = instantiate_node(SyntaxNode,input, index...(index + 3))
          @index += 3
        else
          terminal_parse_failure("nr.")
          r4 = nil
        end
        if r4
          r1 = r4
          r1.extend(AnnotationIdentification0)
        else
          if has_terminal?("nr ", false, index)
            r5 = instantiate_node(SyntaxNode,input, index...(index + 3))
            @index += 3
          else
            terminal_parse_failure("nr ")
            r5 = nil
          end
          if r5
            r1 = r5
            r1.extend(AnnotationIdentification0)
          else
            if has_terminal?("sp.aff.", false, index)
              r6 = instantiate_node(SyntaxNode,input, index...(index + 7))
              @index += 7
            else
              terminal_parse_failure("sp.aff.")
              r6 = nil
            end
            if r6
              r1 = r6
              r1.extend(AnnotationIdentification0)
            else
              if has_terminal?("sp. aff.", false, index)
                r7 = instantiate_node(SyntaxNode,input, index...(index + 8))
                @index += 8
              else
                terminal_parse_failure("sp. aff.")
                r7 = nil
              end
              if r7
                r1 = r7
                r1.extend(AnnotationIdentification0)
              else
                if has_terminal?("sp.", false, index)
                  r8 = instantiate_node(SyntaxNode,input, index...(index + 3))
                  @index += 3
                else
                  terminal_parse_failure("sp.")
                  r8 = nil
                end
                if r8
                  r1 = r8
                  r1.extend(AnnotationIdentification0)
                else
                  if has_terminal?("sp ", false, index)
                    r9 = instantiate_node(SyntaxNode,input, index...(index + 3))
                    @index += 3
                  else
                    terminal_parse_failure("sp ")
                    r9 = nil
                  end
                  if r9
                    r1 = r9
                    r1.extend(AnnotationIdentification0)
                  else
                    if has_terminal?("species", false, index)
                      r10 = instantiate_node(SyntaxNode,input, index...(index + 7))
                      @index += 7
                    else
                      terminal_parse_failure("species")
                      r10 = nil
                    end
                    if r10
                      r1 = r10
                      r1.extend(AnnotationIdentification0)
                    else
                      if has_terminal?("spp.", false, index)
                        r11 = instantiate_node(SyntaxNode,input, index...(index + 4))
                        @index += 4
                      else
                        terminal_parse_failure("spp.")
                        r11 = nil
                      end
                      if r11
                        r1 = r11
                        r1.extend(AnnotationIdentification0)
                      else
                        if has_terminal?("spp ", false, index)
                          r12 = instantiate_node(SyntaxNode,input, index...(index + 4))
                          @index += 4
                        else
                          terminal_parse_failure("spp ")
                          r12 = nil
                        end
                        if r12
                          r1 = r12
                          r1.extend(AnnotationIdentification0)
                        else
                          if has_terminal?("aff.", false, index)
                            r13 = instantiate_node(SyntaxNode,input, index...(index + 4))
                            @index += 4
                          else
                            terminal_parse_failure("aff.")
                            r13 = nil
                          end
                          if r13
                            r1 = r13
                            r1.extend(AnnotationIdentification0)
                          else
                            if has_terminal?("aff ", false, index)
                              r14 = instantiate_node(SyntaxNode,input, index...(index + 4))
                              @index += 4
                            else
                              terminal_parse_failure("aff ")
                              r14 = nil
                            end
                            if r14
                              r1 = r14
                              r1.extend(AnnotationIdentification0)
                            else
                              if has_terminal?("monst.", false, index)
                                r15 = instantiate_node(SyntaxNode,input, index...(index + 6))
                                @index += 6
                              else
                                terminal_parse_failure("monst.")
                                r15 = nil
                              end
                              if r15
                                r1 = r15
                                r1.extend(AnnotationIdentification0)
                              else
                                if has_terminal?("? ", false, index)
                                  r16 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                  @index += 2
                                else
                                  terminal_parse_failure("? ")
                                  r16 = nil
                                end
                                if r16
                                  r1 = r16
                                  r1.extend(AnnotationIdentification0)
                                else
                                  @index = i1
                                  r1 = nil
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
    if r1
      r0 = r1
    else
      i17 = index
      if has_terminal?("cf.", false, index)
        r18 = instantiate_node(SyntaxNode,input, index...(index + 3))
        @index += 3
      else
        terminal_parse_failure("cf.")
        r18 = nil
      end
      if r18
        r17 = r18
        r17.extend(AnnotationIdentification1)
      else
        if has_terminal?("cf ", false, index)
          r19 = instantiate_node(SyntaxNode,input, index...(index + 3))
          @index += 3
        else
          terminal_parse_failure("cf ")
          r19 = nil
        end
        if r19
          r17 = r19
          r17.extend(AnnotationIdentification1)
        else
          @index = i17
          r17 = nil
        end
      end
      if r17
        r0 = r17
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:annotation_identification][start_index] = r0

    r0
  end

  module SpeciesWord0
    def a
      elements[0]
    end

    def b
      elements[2]
    end
  end

  module SpeciesWord1
    def value
      num = {"1" => "uni", "2" => "du", "3" => "tri", "4" => "quadri", "5" => "quinque", "6" => "hexa", "7" => "septem", "8" => "octo", "9" => "novem", "10" => "decem", "11" => "undecim", "12" => "duodec", "13" => "tredec", "14" => "quattuordec", "15" => "quinquadec", "16" => "hexadec", "17" => "septendec", "18" => "octodec", "19" => "novemdec", "20" => "viginti", "21" => "unviginti", "22" => "duodeviginti", "23" => "triviginti", "24" => "quattuorviginti", "25" => "quinquatviginti", "26" => "hexaviginti", "27" => "septenviginti", "28" => "octoviginti", "29" => "novemviginti", "30" => "triginta", "38" => "trigintaocto", "100" => "centi"}
      a_value = num[a.text_value] ? num[a.text_value] : a.text_value + "-"
      a_value + b.value
    end
  end

  def _nt_species_word
    start_index = index
    if node_cache[:species_word].has_key?(index)
      cached = node_cache[:species_word][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    s2, i2 = [], index
    loop do
      if has_terminal?('\G[0-9]', true, index)
        r3 = true
        @index += 1
      else
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s1 << r2
    if r2
      if has_terminal?("-", false, index)
        r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("-")
        r5 = nil
      end
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s1 << r4
      if r4
        r6 = _nt_latin_word
        s1 << r6
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(SpeciesWord0)
      r1.extend(SpeciesWord1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r7 = _nt_latin_word
      if r7
        r0 = r7
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:species_word][start_index] = r0

    r0
  end

  module LatinWord0
    def a
      elements[0]
    end

    def b
      elements[2]
    end
  end

  module LatinWord1
    def value
      a.value + "-" + b.value
    end
  end

  module LatinWord2
    def value
      "odonelli"
    end
  end

  module LatinWord3
    def value
      "oneili"
    end
  end

  module LatinWord4
    def a
      elements[0]
    end

    def b
      elements[1]
    end
  end

  module LatinWord5
    def value
      a.value + b.value
    end
  end

  def _nt_latin_word
    start_index = index
    if node_cache[:latin_word].has_key?(index)
      cached = node_cache[:latin_word][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_valid_name_letters
    s1 << r2
    if r2
      if has_terminal?("-", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("-")
        r3 = nil
      end
      s1 << r3
      if r3
        r4 = _nt_latin_word
        s1 << r4
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(LatinWord0)
      r1.extend(LatinWord1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      if has_terminal?("o'donelli", false, index)
        r5 = instantiate_node(SyntaxNode,input, index...(index + 9))
        r5.extend(LatinWord2)
        @index += 9
      else
        terminal_parse_failure("o'donelli")
        r5 = nil
      end
      if r5
        r0 = r5
      else
        if has_terminal?("o'neili", false, index)
          r6 = instantiate_node(SyntaxNode,input, index...(index + 7))
          r6.extend(LatinWord3)
          @index += 7
        else
          terminal_parse_failure("o'neili")
          r6 = nil
        end
        if r6
          r0 = r6
        else
          i7, s7 = index, []
          r8 = _nt_valid_name_letter
          s7 << r8
          if r8
            r9 = _nt_valid_name_letters
            s7 << r9
          end
          if s7.last
            r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
            r7.extend(LatinWord4)
            r7.extend(LatinWord5)
          else
            @index = i7
            r7 = nil
          end
          if r7
            r0 = r7
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end

    node_cache[:latin_word][start_index] = r0

    r0
  end

  module ValidNameLetters0
    def value
      res = ""
      text_value.split("").each do |l|
        l = "ae" if l == "æ"
        l = "oe" if l == "œ"
        # We normalize ë as well. It is legal in botanical code, but it
        # is beneficial to normalize it for the reconsiliation purposes
        l = "e" if l == "ë"
        res << l
      end
      res
    end
  end

  def _nt_valid_name_letters
    start_index = index
    if node_cache[:valid_name_letters].has_key?(index)
      cached = node_cache[:valid_name_letters][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    s0, i0 = [], index
    loop do
      if has_terminal?('\G[a-zëæœ]', true, index)
        r1 = true
        @index += 1
      else
        r1 = nil
      end
      if r1
        s0 << r1
      else
        break
      end
    end
    if s0.empty?
      @index = i0
      r0 = nil
    else
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(ValidNameLetters0)
    end

    node_cache[:valid_name_letters][start_index] = r0

    r0
  end

  module ValidNameLetter0
    def value
      res = text_value
      res = "ae" if res == "æ"
      res = "oe" if res == "œ"
      res = "e"  if res == "ë"
      res
    end
  end

  def _nt_valid_name_letter
    start_index = index
    if node_cache[:valid_name_letter].has_key?(index)
      cached = node_cache[:valid_name_letter][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    if has_terminal?('\G[a-zëæœ]', true, index)
      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
      r0.extend(ValidNameLetter0)
      @index += 1
    else
      r0 = nil
    end

    node_cache[:valid_name_letter][start_index] = r0

    r0
  end

  module CapDigraph0
    def value
    "Ae"
    end
  end

  module CapDigraph1
    def value
    "Oe"
    end
  end

  def _nt_cap_digraph
    start_index = index
    if node_cache[:cap_digraph].has_key?(index)
      cached = node_cache[:cap_digraph][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    if has_terminal?("Æ", false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
      r1.extend(CapDigraph0)
      @index += 1
    else
      terminal_parse_failure("Æ")
      r1 = nil
    end
    if r1
      r0 = r1
    else
      if has_terminal?("Œ", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        r2.extend(CapDigraph1)
        @index += 1
      else
        terminal_parse_failure("Œ")
        r2 = nil
      end
      if r2
        r0 = r2
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:cap_digraph][start_index] = r0

    r0
  end

  module Year0
    def b
      elements[0]
    end

    def space1
      elements[1]
    end

    def a
      elements[2]
    end

    def space2
      elements[3]
    end

    def c
      elements[4]
    end
  end

  module Year1
    def value
      a.value
    end

    def pos
      a.pos
    end

    def details
      a.details
    end
  end

  def _nt_year
    start_index = index
    if node_cache[:year].has_key?(index)
      cached = node_cache[:year][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1, s1 = index, []
    r2 = _nt_left_paren
    s1 << r2
    if r2
      r3 = _nt_space
      s1 << r3
      if r3
        i4 = index
        r5 = _nt_year_number_with_character
        if r5
          r4 = r5
        else
          r6 = _nt_year_number
          if r6
            r4 = r6
          else
            @index = i4
            r4 = nil
          end
        end
        s1 << r4
        if r4
          r7 = _nt_space
          s1 << r7
          if r7
            r8 = _nt_right_paren
            s1 << r8
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Year0)
      r1.extend(Year1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r9 = _nt_year_number_with_character
      if r9
        r0 = r9
      else
        r10 = _nt_year_number
        if r10
          r0 = r10
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:year][start_index] = r0

    r0
  end

  module YearNumberWithCharacter0
    def a
      elements[0]
    end

  end

  module YearNumberWithCharacter1
    def value
      a.text_value
    end

    def pos
      {interval.begin => ["year", interval.end]}
    end

    def details
      {:year => value}
    end
  end

  def _nt_year_number_with_character
    start_index = index
    if node_cache[:year_number_with_character].has_key?(index)
      cached = node_cache[:year_number_with_character][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_year_number
    s0 << r1
    if r1
      if has_terminal?('\G[a-zA-Z]', true, index)
        r2 = true
        @index += 1
      else
        r2 = nil
      end
      s0 << r2
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(YearNumberWithCharacter0)
      r0.extend(YearNumberWithCharacter1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:year_number_with_character][start_index] = r0

    r0
  end

  module YearNumber0
  end

  module YearNumber1
  end

  module YearNumber2
    def value
      text_value
    end

    def pos
      {interval.begin => ["year", interval.end]}
    end

    def details
      {:year => value}
    end
  end

  def _nt_year_number
    start_index = index
    if node_cache[:year_number].has_key?(index)
      cached = node_cache[:year_number][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    if has_terminal?('\G[12]', true, index)
      r1 = true
      @index += 1
    else
      r1 = nil
    end
    s0 << r1
    if r1
      if has_terminal?('\G[7890]', true, index)
        r2 = true
        @index += 1
      else
        r2 = nil
      end
      s0 << r2
      if r2
        if has_terminal?('\G[0-9]', true, index)
          r3 = true
          @index += 1
        else
          r3 = nil
        end
        s0 << r3
        if r3
          i4 = index
          i5, s5 = index, []
          if has_terminal?('\G[0-9]', true, index)
            r6 = true
            @index += 1
          else
            r6 = nil
          end
          s5 << r6
          if r6
            if has_terminal?('\G[\\?]', true, index)
              r8 = true
              @index += 1
            else
              r8 = nil
            end
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s5 << r7
          end
          if s5.last
            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
            r5.extend(YearNumber0)
          else
            @index = i5
            r5 = nil
          end
          if r5
            r4 = r5
          else
            if has_terminal?("?", false, index)
              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure("?")
              r9 = nil
            end
            if r9
              r4 = r9
            else
              @index = i4
              r4 = nil
            end
          end
          s0 << r4
        end
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(YearNumber1)
      r0.extend(YearNumber2)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:year_number][start_index] = r0

    r0
  end

  def _nt_left_paren
    start_index = index
    if node_cache[:left_paren].has_key?(index)
      cached = node_cache[:left_paren][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    if has_terminal?("(", false, index)
      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure("(")
      r0 = nil
    end

    node_cache[:left_paren][start_index] = r0

    r0
  end

  def _nt_right_paren
    start_index = index
    if node_cache[:right_paren].has_key?(index)
      cached = node_cache[:right_paren][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    if has_terminal?(")", false, index)
      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure(")")
      r0 = nil
    end

    node_cache[:right_paren][start_index] = r0

    r0
  end

  module HybridCharacter0
    def value
      "×"
    end
  end

  def _nt_hybrid_character
    start_index = index
    if node_cache[:hybrid_character].has_key?(index)
      cached = node_cache[:hybrid_character][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    i1 = index
    if has_terminal?("x", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure("x")
      r2 = nil
    end
    if r2
      r1 = r2
      r1.extend(HybridCharacter0)
    else
      if has_terminal?("X", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("X")
        r3 = nil
      end
      if r3
        r1 = r3
        r1.extend(HybridCharacter0)
      else
        @index = i1
        r1 = nil
      end
    end
    if r1
      r0 = r1
    else
      r4 = _nt_multiplication_sign
      if r4
        r0 = r4
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:hybrid_character][start_index] = r0

    r0
  end

  module MultiplicationSign0
    def value
      "×"
    end
  end

  def _nt_multiplication_sign
    start_index = index
    if node_cache[:multiplication_sign].has_key?(index)
      cached = node_cache[:multiplication_sign][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    if has_terminal?("×", false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure("×")
      r1 = nil
    end
    if r1
      r0 = r1
      r0.extend(MultiplicationSign0)
    else
      if has_terminal?("*", false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("*")
        r2 = nil
      end
      if r2
        r0 = r2
        r0.extend(MultiplicationSign0)
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:multiplication_sign][start_index] = r0

    r0
  end

  def _nt_space
    start_index = index
    if node_cache[:space].has_key?(index)
      cached = node_cache[:space][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    s0, i0 = [], index
    loop do
      if has_terminal?('\G[\\s]', true, index)
        r1 = true
        @index += 1
      else
        r1 = nil
      end
      if r1
        s0 << r1
      else
        break
      end
    end
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)

    node_cache[:space][start_index] = r0

    r0
  end

  def _nt_space_hard
    start_index = index
    if node_cache[:space_hard].has_key?(index)
      cached = node_cache[:space_hard][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    s0, i0 = [], index
    loop do
      if has_terminal?('\G[\\s]', true, index)
        r1 = true
        @index += 1
      else
        r1 = nil
      end
      if r1
        s0 << r1
      else
        break
      end
    end
    if s0.empty?
      @index = i0
      r0 = nil
    else
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    end

    node_cache[:space_hard][start_index] = r0

    r0
  end

end

class ScientificNameCleanParser < Treetop::Runtime::CompiledParser
  include ScientificNameClean
end