Module: ScientificNameClean

Includes:: Treetop::Runtime

Included in:: ScientificNameCleanParser, ScientificNameDirty

Defined in:: lib/biodiversity/parser/scientific_name_clean.rb

Defined Under Namespace

Instance Method Summary collapse

Instance Method Details

#_nt_abbreviated_genus ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 3245

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

#_nt_annotation_identification ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 6681

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

#_nt_author_name ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 4997

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

#_nt_author_name_without_postfix ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 5124

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

#_nt_author_postfix_word ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 5836

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

#_nt_author_prefix_word ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 5605

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

#_nt_author_separator ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 4880

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

#_nt_author_word ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 5264

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

#_nt_authors_names ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 4587

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

#_nt_authorship ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 3684

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

#_nt_basionym_authorship_with_parenthesis ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 3992

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

#_nt_cap_digraph ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7232

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

#_nt_cap_latin_word ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 5993

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

#_nt_cap_latin_word_pair ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 5896

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

#_nt_capped_dotted_char ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 6382

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

#_nt_ex_authorship ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 4220

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

#_nt_ex_sep ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 4797

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

#_nt_genus ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 3149

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

#_nt_hybrid_character ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7618

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

#_nt_infragenus ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 3050

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

#_nt_infraspecies ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 1708

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

#_nt_infraspecies_mult ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 1627

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

#_nt_infraspecies_string ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 1851

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

#_nt_latin_word ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7053

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
      i6, s6 = index, []
      r7 = _nt_valid_name_letter
      s6 << r7
      if r7
        r8 = _nt_valid_name_letters
        s6 << r8
      end
      if s6.last
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        r6.extend(LatinWord3)
        r6.extend(LatinWord4)
      else
        @index = i6
        r6 = nil
      end
      if r6
        r0 = r6
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:latin_word][start_index] = r0

  r0
end

#_nt_left_paren ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7564

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

#_nt_multinomial_name ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 1207

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

#_nt_multiplication_sign ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7680

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

#_nt_multiuninomial_name ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 1539

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

#_nt_rank ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 2043

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?("fma.", false, index)
                                              r22 = instantiate_node(SyntaxNode,input, index...(index + 4))
                                              @index += 4
                                            else
                                              terminal_parse_failure("fma.")
                                              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?("form.", false, index)
                                                  r24 = instantiate_node(SyntaxNode,input, index...(index + 5))
                                                  @index += 5
                                                else
                                                  terminal_parse_failure("form.")
                                                  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?("fo.", false, index)
                                                      r26 = instantiate_node(SyntaxNode,input, index...(index + 3))
                                                      @index += 3
                                                    else
                                                      terminal_parse_failure("fo.")
                                                      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?("f.", false, index)
                                                          r28 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                          @index += 2
                                                        else
                                                          terminal_parse_failure("f.")
                                                          r28 = nil
                                                        end
                                                        if r28
                                                          r0 = r28
                                                          r0.extend(Rank0)
                                                        else
                                                          if has_terminal?("α", false, index)
                                                            r29 = instantiate_node(SyntaxNode,input, index...(index + 1))
                                                            @index += 1
                                                          else
                                                            terminal_parse_failure("α")
                                                            r29 = nil
                                                          end
                                                          if r29
                                                            r0 = r29
                                                            r0.extend(Rank0)
                                                          else
                                                            if has_terminal?("ββ", false, index)
                                                              r30 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                              @index += 2
                                                            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 + 1))
                                                                @index += 1
                                                              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?("a.", false, index)
                                                                              r38 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                              @index += 2
                                                                            else
                                                                              terminal_parse_failure("a.")
                                                                              r38 = nil
                                                                            end
                                                                            if r38
                                                                              r0 = r38
                                                                              r0.extend(Rank0)
                                                                            else
                                                                              if has_terminal?("b.", false, index)
                                                                                r39 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                @index += 2
                                                                              else
                                                                                terminal_parse_failure("b.")
                                                                                r39 = nil
                                                                              end
                                                                              if r39
                                                                                r0 = r39
                                                                                r0.extend(Rank0)
                                                                              else
                                                                                if has_terminal?("c.", false, index)
                                                                                  r40 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                  @index += 2
                                                                                else
                                                                                  terminal_parse_failure("c.")
                                                                                  r40 = nil
                                                                                end
                                                                                if r40
                                                                                  r0 = r40
                                                                                  r0.extend(Rank0)
                                                                                else
                                                                                  if has_terminal?("d.", false, index)
                                                                                    r41 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                    @index += 2
                                                                                  else
                                                                                    terminal_parse_failure("d.")
                                                                                    r41 = nil
                                                                                  end
                                                                                  if r41
                                                                                    r0 = r41
                                                                                    r0.extend(Rank0)
                                                                                  else
                                                                                    if has_terminal?("e.", false, index)
                                                                                      r42 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                      @index += 2
                                                                                    else
                                                                                      terminal_parse_failure("e.")
                                                                                      r42 = nil
                                                                                    end
                                                                                    if r42
                                                                                      r0 = r42
                                                                                      r0.extend(Rank0)
                                                                                    else
                                                                                      if has_terminal?("g.", false, index)
                                                                                        r43 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                        @index += 2
                                                                                      else
                                                                                        terminal_parse_failure("g.")
                                                                                        r43 = nil
                                                                                      end
                                                                                      if r43
                                                                                        r0 = r43
                                                                                        r0.extend(Rank0)
                                                                                      else
                                                                                        if has_terminal?("k.", false, index)
                                                                                          r44 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                          @index += 2
                                                                                        else
                                                                                          terminal_parse_failure("k.")
                                                                                          r44 = nil
                                                                                        end
                                                                                        if r44
                                                                                          r0 = r44
                                                                                          r0.extend(Rank0)
                                                                                        else
                                                                                          if has_terminal?("****", false, index)
                                                                                            r45 = instantiate_node(SyntaxNode,input, index...(index + 4))
                                                                                            @index += 4
                                                                                          else
                                                                                            terminal_parse_failure("****")
                                                                                            r45 = nil
                                                                                          end
                                                                                          if r45
                                                                                            r0 = r45
                                                                                            r0.extend(Rank0)
                                                                                          else
                                                                                            if has_terminal?("**", false, index)
                                                                                              r46 = instantiate_node(SyntaxNode,input, index...(index + 2))
                                                                                              @index += 2
                                                                                            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 + 1))
                                                                                                @index += 1
                                                                                              else
                                                                                                terminal_parse_failure("*")
                                                                                                r47 = nil
                                                                                              end
                                                                                              if r47
                                                                                                r0 = r47
                                                                                                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

  node_cache[:rank][start_index] = r0

  r0
end

#_nt_rank_uninomial ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 2641

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

#_nt_right_paren ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7588

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

#_nt_root ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 54

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

#_nt_scientific_name_1 ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 615

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

#_nt_scientific_name_2 ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 567

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

#_nt_scientific_name_3 ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 483

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

#_nt_scientific_name_4 ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 350

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

#_nt_scientific_name_5 ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 178

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

#_nt_simple_authorship ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 4376

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

#_nt_space ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7724

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

#_nt_space_hard ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7756

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

#_nt_species ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 2913

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

#_nt_species_string ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 2979

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

#_nt_species_word ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 6937

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

#_nt_species_word_hybrid ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 6533

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

#_nt_status_part ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 673

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

#_nt_status_word ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 737

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

#_nt_taxon_concept_rank ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 1976

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

#_nt_uninomial_name ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 3435

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

#_nt_uninomial_string ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 3555

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

#_nt_unknown_auth ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 4665

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

#_nt_unparsed ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 803

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

#_nt_valid_name_letter ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7196

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

#_nt_valid_name_letters ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7148

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

#_nt_year ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7312

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

#_nt_year_number ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7463

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

#_nt_year_number_with_character ⇒ `Object`

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 7406

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

#root ⇒ `Object`



10
11
12

# File 'lib/biodiversity/parser/scientific_name_clean.rb', line 10

def root
  @root ||= :root
end

Module: ScientificNameClean

Defined Under Namespace

Instance Method Summary collapse

Instance Method Details

#_nt_abbreviated_genus ⇒ Object

#_nt_annotation_identification ⇒ Object

#_nt_author_name ⇒ Object

#_nt_author_name_without_postfix ⇒ Object

#_nt_author_postfix_word ⇒ Object

#_nt_author_prefix_word ⇒ Object

#_nt_author_separator ⇒ Object

#_nt_author_word ⇒ Object

#_nt_authors_names ⇒ Object

#_nt_authorship ⇒ Object

#_nt_basionym_authorship_with_parenthesis ⇒ Object

#_nt_cap_digraph ⇒ Object

#_nt_cap_latin_word ⇒ Object

#_nt_cap_latin_word_pair ⇒ Object

#_nt_capped_dotted_char ⇒ Object

#_nt_ex_authorship ⇒ Object

#_nt_ex_sep ⇒ Object

#_nt_genus ⇒ Object

#_nt_hybrid_character ⇒ Object

#_nt_infragenus ⇒ Object

#_nt_infraspecies ⇒ Object

#_nt_infraspecies_mult ⇒ Object

#_nt_infraspecies_string ⇒ Object

#_nt_latin_word ⇒ Object

#_nt_left_paren ⇒ Object

#_nt_multinomial_name ⇒ Object

#_nt_multiplication_sign ⇒ Object

#_nt_multiuninomial_name ⇒ Object

#_nt_rank ⇒ Object

#_nt_rank_uninomial ⇒ Object

#_nt_right_paren ⇒ Object

#_nt_root ⇒ Object

#_nt_scientific_name_1 ⇒ Object

#_nt_scientific_name_2 ⇒ Object

#_nt_scientific_name_3 ⇒ Object

#_nt_scientific_name_4 ⇒ Object

#_nt_scientific_name_5 ⇒ Object

#_nt_simple_authorship ⇒ Object

#_nt_space ⇒ Object

#_nt_space_hard ⇒ Object

#_nt_species ⇒ Object

#_nt_species_string ⇒ Object

#_nt_species_word ⇒ Object

#_nt_species_word_hybrid ⇒ Object

#_nt_status_part ⇒ Object

#_nt_status_word ⇒ Object

#_nt_taxon_concept_rank ⇒ Object

#_nt_uninomial_name ⇒ Object

#_nt_uninomial_string ⇒ Object

#_nt_unknown_auth ⇒ Object

#_nt_unparsed ⇒ Object

#_nt_valid_name_letter ⇒ Object

#_nt_valid_name_letters ⇒ Object

#_nt_year ⇒ Object

#_nt_year_number ⇒ Object

#_nt_year_number_with_character ⇒ Object

#root ⇒ Object

#_nt_abbreviated_genus ⇒ `Object`

#_nt_annotation_identification ⇒ `Object`

#_nt_author_name ⇒ `Object`

#_nt_author_name_without_postfix ⇒ `Object`

#_nt_author_postfix_word ⇒ `Object`

#_nt_author_prefix_word ⇒ `Object`

#_nt_author_separator ⇒ `Object`

#_nt_author_word ⇒ `Object`

#_nt_authors_names ⇒ `Object`

#_nt_authorship ⇒ `Object`

#_nt_basionym_authorship_with_parenthesis ⇒ `Object`

#_nt_cap_digraph ⇒ `Object`

#_nt_cap_latin_word ⇒ `Object`

#_nt_cap_latin_word_pair ⇒ `Object`

#_nt_capped_dotted_char ⇒ `Object`

#_nt_ex_authorship ⇒ `Object`

#_nt_ex_sep ⇒ `Object`

#_nt_genus ⇒ `Object`

#_nt_hybrid_character ⇒ `Object`

#_nt_infragenus ⇒ `Object`

#_nt_infraspecies ⇒ `Object`

#_nt_infraspecies_mult ⇒ `Object`

#_nt_infraspecies_string ⇒ `Object`

#_nt_latin_word ⇒ `Object`

#_nt_left_paren ⇒ `Object`

#_nt_multinomial_name ⇒ `Object`

#_nt_multiplication_sign ⇒ `Object`

#_nt_multiuninomial_name ⇒ `Object`

#_nt_rank ⇒ `Object`

#_nt_rank_uninomial ⇒ `Object`

#_nt_right_paren ⇒ `Object`

#_nt_root ⇒ `Object`

#_nt_scientific_name_1 ⇒ `Object`

#_nt_scientific_name_2 ⇒ `Object`

#_nt_scientific_name_3 ⇒ `Object`

#_nt_scientific_name_4 ⇒ `Object`

#_nt_scientific_name_5 ⇒ `Object`

#_nt_simple_authorship ⇒ `Object`

#_nt_space ⇒ `Object`

#_nt_space_hard ⇒ `Object`

#_nt_species ⇒ `Object`

#_nt_species_string ⇒ `Object`

#_nt_species_word ⇒ `Object`

#_nt_species_word_hybrid ⇒ `Object`

#_nt_status_part ⇒ `Object`

#_nt_status_word ⇒ `Object`

#_nt_taxon_concept_rank ⇒ `Object`

#_nt_uninomial_name ⇒ `Object`

#_nt_uninomial_string ⇒ `Object`

#_nt_unknown_auth ⇒ `Object`

#_nt_unparsed ⇒ `Object`

#_nt_valid_name_letter ⇒ `Object`

#_nt_valid_name_letters ⇒ `Object`

#_nt_year ⇒ `Object`

#_nt_year_number ⇒ `Object`

#_nt_year_number_with_character ⇒ `Object`

#root ⇒ `Object`