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 3458

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

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[A-Z]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[a-z]'] ||= Regexp.new(gr), :regexp, index)
      r3 = true
      @index += 1
    else
      terminal_parse_failure('[a-z]')
      r3 = nil
    end
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[a-z]'] ||= Regexp.new(gr), :regexp, index)
        r5 = true
        @index += 1
      else
        terminal_parse_failure('[a-z]')
        r5 = nil
      end
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
      if r4
        if has_terminal?(@regexps[gr = '\A[\\\\.]'] ||= Regexp.new(gr), :regexp, index)
          r6 = true
          @index += 1
        else
          terminal_parse_failure('[\\\\.]')
          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 7774

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

  i0 = index
  i1 = index
  if (match_len = has_terminal?("sp.nr.", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"sp.nr."')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
    r1.extend(AnnotationIdentification0)
    r1.extend(AnnotationIdentification0)
  else
    if (match_len = has_terminal?("sp. nr.", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"sp. nr."')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
      r1.extend(AnnotationIdentification0)
      r1.extend(AnnotationIdentification0)
    else
      if (match_len = has_terminal?("nr.", false, index))
        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"nr."')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r1 = r4
        r1.extend(AnnotationIdentification0)
        r1.extend(AnnotationIdentification0)
      else
        if (match_len = has_terminal?("nr ", false, index))
          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"nr "')
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r1 = r5
          r1.extend(AnnotationIdentification0)
          r1.extend(AnnotationIdentification0)
        else
          if (match_len = has_terminal?("sp.aff.", false, index))
            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"sp.aff."')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r1 = r6
            r1.extend(AnnotationIdentification0)
            r1.extend(AnnotationIdentification0)
          else
            if (match_len = has_terminal?("sp. aff.", false, index))
              r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"sp. aff."')
              r7 = nil
            end
            if r7
              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
              r1 = r7
              r1.extend(AnnotationIdentification0)
              r1.extend(AnnotationIdentification0)
            else
              if (match_len = has_terminal?("sp.", false, index))
                r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"sp."')
                r8 = nil
              end
              if r8
                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                r1 = r8
                r1.extend(AnnotationIdentification0)
                r1.extend(AnnotationIdentification0)
              else
                if (match_len = has_terminal?("sp ", false, index))
                  r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"sp "')
                  r9 = nil
                end
                if r9
                  r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                  r1 = r9
                  r1.extend(AnnotationIdentification0)
                  r1.extend(AnnotationIdentification0)
                else
                  if (match_len = has_terminal?("species", false, index))
                    r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                    @index += match_len
                  else
                    terminal_parse_failure('"species"')
                    r10 = nil
                  end
                  if r10
                    r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                    r1 = r10
                    r1.extend(AnnotationIdentification0)
                    r1.extend(AnnotationIdentification0)
                  else
                    if (match_len = has_terminal?("spp.", false, index))
                      r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                      @index += match_len
                    else
                      terminal_parse_failure('"spp."')
                      r11 = nil
                    end
                    if r11
                      r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
                      r1 = r11
                      r1.extend(AnnotationIdentification0)
                      r1.extend(AnnotationIdentification0)
                    else
                      if (match_len = has_terminal?("spp ", false, index))
                        r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                        @index += match_len
                      else
                        terminal_parse_failure('"spp "')
                        r12 = nil
                      end
                      if r12
                        r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                        r1 = r12
                        r1.extend(AnnotationIdentification0)
                        r1.extend(AnnotationIdentification0)
                      else
                        if (match_len = has_terminal?("aff.", false, index))
                          r13 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                          @index += match_len
                        else
                          terminal_parse_failure('"aff."')
                          r13 = nil
                        end
                        if r13
                          r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
                          r1 = r13
                          r1.extend(AnnotationIdentification0)
                          r1.extend(AnnotationIdentification0)
                        else
                          if (match_len = has_terminal?("aff ", false, index))
                            r14 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"aff "')
                            r14 = nil
                          end
                          if r14
                            r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
                            r1 = r14
                            r1.extend(AnnotationIdentification0)
                            r1.extend(AnnotationIdentification0)
                          else
                            if (match_len = has_terminal?("monst.", false, index))
                              r15 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                              @index += match_len
                            else
                              terminal_parse_failure('"monst."')
                              r15 = nil
                            end
                            if r15
                              r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
                              r1 = r15
                              r1.extend(AnnotationIdentification0)
                              r1.extend(AnnotationIdentification0)
                            else
                              if (match_len = has_terminal?("? ", false, index))
                                r16 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                @index += match_len
                              else
                                terminal_parse_failure('"? "')
                                r16 = nil
                              end
                              if r16
                                r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
                                r1 = r16
                                r1.extend(AnnotationIdentification0)
                                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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i17 = index
    if (match_len = has_terminal?("cf.", false, index))
      r18 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"cf."')
      r18 = nil
    end
    if r18
      r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
      r17 = r18
      r17.extend(AnnotationIdentification1)
      r17.extend(AnnotationIdentification1)
    else
      if (match_len = has_terminal?("cf ", false, index))
        r19 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"cf "')
        r19 = nil
      end
      if r19
        r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
        r17 = r19
        r17.extend(AnnotationIdentification1)
        r17.extend(AnnotationIdentification1)
      else
        @index = i17
        r17 = nil
      end
    end
    if r17
      r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
      r0 = r17
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:annotation_identification][start_index] = r0

  r0
end

#_nt_author_filius ⇒ `Object`

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

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

  i0 = index
  if (match_len = has_terminal?("fil.", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"fil."')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(AuthorFilius0)
    r0.extend(AuthorFilius0)
  else
    if (match_len = has_terminal?("filius", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"filius"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
      r0.extend(AuthorFilius0)
      r0.extend(AuthorFilius0)
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:author_filius][start_index] = r0

  r0
end

#_nt_author_maybe_filius ⇒ `Object`

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

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

  if (match_len = has_terminal?("f.", false, index))
    r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r0.extend(AuthorMaybeFilius0)
    @index += match_len
  else
    terminal_parse_failure('"f."')
    r0 = nil
  end

  node_cache[:author_maybe_filius][start_index] = r0

  r0
end

#_nt_author_name ⇒ `Object`

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

def _nt_author_name
  start_index = index
  if node_cache[:author_name].has_key?(index)
    cached = node_cache[:author_name][index]
    if cached
      node_cache[:author_name][index] = 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_maybe_filius
        s1 << r5
        if r5
          r6 = _nt_space
          s1 << r6
          if r6
            i7 = index
            r8 = _nt_latin_word
            if r8
              @index = i7
              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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i9, s9 = index, []
    r10 = _nt_space
    s9 << r10
    if r10
      r11 = _nt_author_name_without_postfix
      s9 << r11
      if r11
        r12 = _nt_space
        s9 << r12
        if r12
          r13 = _nt_author_filius
          s9 << r13
        end
      end
    end
    if s9.last
      r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
      r9.extend(AuthorName2)
      r9.extend(AuthorName3)
    else
      @index = i9
      r9 = nil
    end
    if r9
      r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
      r0 = r9
    else
      r14 = _nt_author_name_without_postfix
      if r14
        r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
        r0 = r14
      else
        @index = i0
        r0 = nil
      end
    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 5972

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
      node_cache[:author_name_without_postfix][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    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
      r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
      r0 = r6
    else
      r10 = _nt_author_word
      if r10
        r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
        r0 = r10
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:author_name_without_postfix][start_index] = r0

  r0
end

#_nt_author_prefix_word ⇒ `Object`

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

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
      node_cache[:author_prefix_word][index] = 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 (match_len = has_terminal?("ab", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"ab"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r2 = r3
    else
      if (match_len = has_terminal?("af", false, index))
        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"af"')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r2 = r4
      else
        if (match_len = has_terminal?("bis", false, index))
          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"bis"')
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r2 = r5
        else
          if (match_len = has_terminal?("da", false, index))
            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"da"')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r2 = r6
          else
            if (match_len = has_terminal?("der", false, index))
              r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"der"')
              r7 = nil
            end
            if r7
              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
              r2 = r7
            else
              if (match_len = has_terminal?("del", false, index))
                r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"del"')
                r8 = nil
              end
              if r8
                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                r2 = r8
              else
                if (match_len = has_terminal?("des", false, index))
                  r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"des"')
                  r9 = nil
                end
                if r9
                  r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                  r2 = r9
                else
                  if (match_len = has_terminal?("den", false, index))
                    r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                    @index += match_len
                  else
                    terminal_parse_failure('"den"')
                    r10 = nil
                  end
                  if r10
                    r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                    r2 = r10
                  else
                    if (match_len = has_terminal?("della", false, index))
                      r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                      @index += match_len
                    else
                      terminal_parse_failure('"della"')
                      r11 = nil
                    end
                    if r11
                      r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
                      r2 = r11
                    else
                      if (match_len = has_terminal?("dela", false, index))
                        r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                        @index += match_len
                      else
                        terminal_parse_failure('"dela"')
                        r12 = nil
                      end
                      if r12
                        r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                        r2 = r12
                      else
                        if (match_len = has_terminal?("de", false, index))
                          r13 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                          @index += match_len
                        else
                          terminal_parse_failure('"de"')
                          r13 = nil
                        end
                        if r13
                          r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
                          r2 = r13
                        else
                          if (match_len = has_terminal?("di", false, index))
                            r14 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"di"')
                            r14 = nil
                          end
                          if r14
                            r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
                            r2 = r14
                          else
                            if (match_len = has_terminal?("du", false, index))
                              r15 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                              @index += match_len
                            else
                              terminal_parse_failure('"du"')
                              r15 = nil
                            end
                            if r15
                              r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
                              r2 = r15
                            else
                              if (match_len = has_terminal?("do", false, index))
                                r16 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                @index += match_len
                              else
                                terminal_parse_failure('"do"')
                                r16 = nil
                              end
                              if r16
                                r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
                                r2 = r16
                              else
                                if (match_len = has_terminal?("la", false, index))
                                  r17 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                  @index += match_len
                                else
                                  terminal_parse_failure('"la"')
                                  r17 = nil
                                end
                                if r17
                                  r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
                                  r2 = r17
                                else
                                  if (match_len = has_terminal?("'t", false, index))
                                    r18 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                    @index += match_len
                                  else
                                    terminal_parse_failure('"\'t"')
                                    r18 = nil
                                  end
                                  if r18
                                    r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
                                    r2 = r18
                                  else
                                    if (match_len = has_terminal?("ter", false, index))
                                      r19 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                      @index += match_len
                                    else
                                      terminal_parse_failure('"ter"')
                                      r19 = nil
                                    end
                                    if r19
                                      r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
                                      r2 = r19
                                    else
                                      if (match_len = has_terminal?("van", false, index))
                                        r20 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                        @index += match_len
                                      else
                                        terminal_parse_failure('"van"')
                                        r20 = nil
                                      end
                                      if r20
                                        r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
                                        r2 = r20
                                      else
                                        if (match_len = has_terminal?("von", false, index))
                                          r21 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                          @index += match_len
                                        else
                                          terminal_parse_failure('"von"')
                                          r21 = nil
                                        end
                                        if r21
                                          r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
                                          r2 = r21
                                        else
                                          @index = i2
                                          r2 = nil
                                        end
                                      end
                                    end
                                  end
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
    s0 << r2
    if r2
      i22 = index
      r23 = _nt_space_hard
      if r23
        @index = i22
        r22 = instantiate_node(SyntaxNode,input, index...index)
      else
        @index = i22
        r22 = nil
      end
      s0 << r22
    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 5585

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

  i0 = index
  if (match_len = has_terminal?("&amp;", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"&amp;"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(AuthorSeparator0)
    r0.extend(AuthorSeparator0)
  else
    if (match_len = has_terminal?("&", false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('"&"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
      r0.extend(AuthorSeparator0)
      r0.extend(AuthorSeparator0)
    else
      if (match_len = has_terminal?(",&", false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('",&"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
        r0.extend(AuthorSeparator0)
        r0.extend(AuthorSeparator0)
      else
        if (match_len = has_terminal?(", &", false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('", &"')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
          r0.extend(AuthorSeparator0)
          r0.extend(AuthorSeparator0)
        else
          if (match_len = has_terminal?(",and", false, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('",and"')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
            r0.extend(AuthorSeparator0)
            r0.extend(AuthorSeparator0)
          else
            if (match_len = has_terminal?(", and", false, index))
              r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('", and"')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
              r0.extend(AuthorSeparator0)
              r0.extend(AuthorSeparator0)
            else
              if (match_len = has_terminal?("apud", false, index))
                r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"apud"')
                r7 = nil
              end
              if r7
                r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                r0 = r7
                r0.extend(AuthorSeparator0)
                r0.extend(AuthorSeparator0)
              else
                if (match_len = has_terminal?("and", false, index))
                  r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"and"')
                  r8 = nil
                end
                if r8
                  r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                  r0 = r8
                  r0.extend(AuthorSeparator0)
                  r0.extend(AuthorSeparator0)
                else
                  if (match_len = has_terminal?("et", false, index))
                    r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                    @index += match_len
                  else
                    terminal_parse_failure('"et"')
                    r9 = nil
                  end
                  if r9
                    r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                    r0 = r9
                    r0.extend(AuthorSeparator0)
                    r0.extend(AuthorSeparator0)
                  else
                    if (match_len = has_terminal?(",", false, index))
                      r10 = true
                      @index += match_len
                    else
                      terminal_parse_failure('","')
                      r10 = nil
                    end
                    if r10
                      r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                      r0 = r10
                      r0.extend(AuthorSeparator0)
                      r0.extend(AuthorSeparator0)
                    else
                      @index = i0
                      r0 = nil
                    end
                  end
                end
              end
            end
          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 6118

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

  i0 = index
  if (match_len = has_terminal?("A S. Xu", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r1.extend(AuthorWord0)
    @index += match_len
  else
    terminal_parse_failure('"A S. Xu"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2 = index
    if (match_len = has_terminal?("arg.", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"arg."')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r2 = r3
      r2.extend(AuthorWord1)
      r2.extend(AuthorWord1)
    else
      if (match_len = has_terminal?("et al.\{\?\}", false, index))
        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"et al.\\{\\?\\}"')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r2 = r4
        r2.extend(AuthorWord1)
        r2.extend(AuthorWord1)
      else
        if (match_len = has_terminal?("et al.", false, index))
          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"et al."')
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r2 = r5
          r2.extend(AuthorWord1)
          r2.extend(AuthorWord1)
        else
          if (match_len = has_terminal?("et al", false, index))
            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"et al"')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r2 = r6
            r2.extend(AuthorWord1)
            r2.extend(AuthorWord1)
          else
            if (match_len = has_terminal?("& al.", false, index))
              r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"& al."')
              r7 = nil
            end
            if r7
              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
              r2 = r7
              r2.extend(AuthorWord1)
              r2.extend(AuthorWord1)
            else
              if (match_len = has_terminal?("& al", false, index))
                r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"& al"')
                r8 = nil
              end
              if r8
                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                r2 = r8
                r2.extend(AuthorWord1)
                r2.extend(AuthorWord1)
              else
                @index = i2
                r2 = nil
              end
            end
          end
        end
      end
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      i9, s9 = index, []
      i11, s11 = index, []
      if (match_len = has_terminal?("d", false, index))
        r12 = true
        @index += match_len
      else
        terminal_parse_failure('"d"')
        r12 = nil
      end
      s11 << r12
      if r12
        if has_terminal?(@regexps[gr = '\A[\'’]'] ||= Regexp.new(gr), :regexp, index)
          r13 = true
          @index += 1
        else
          terminal_parse_failure('[\'’]')
          r13 = nil
        end
        s11 << r13
      end
      if s11.last
        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
        r11.extend(AuthorWord2)
      else
        @index = i11
        r11 = nil
      end
      if r11
        r10 = r11
      else
        r10 = instantiate_node(SyntaxNode,input, index...index)
      end
      s9 << r10
      if r10
        i14 = index
        if (match_len = has_terminal?("Å", false, index))
          r15 = true
          @index += match_len
        else
          terminal_parse_failure('"Å"')
          r15 = nil
        end
        if r15
          r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
          r14 = r15
        else
          if (match_len = has_terminal?("Ö", false, index))
            r16 = true
            @index += match_len
          else
            terminal_parse_failure('"Ö"')
            r16 = nil
          end
          if r16
            r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
            r14 = r16
          else
            if (match_len = has_terminal?("Á", false, index))
              r17 = true
              @index += match_len
            else
              terminal_parse_failure('"Á"')
              r17 = nil
            end
            if r17
              r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
              r14 = r17
            else
              if (match_len = has_terminal?("Ø", false, index))
                r18 = true
                @index += match_len
              else
                terminal_parse_failure('"Ø"')
                r18 = nil
              end
              if r18
                r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
                r14 = r18
              else
                if (match_len = has_terminal?("Ô", false, index))
                  r19 = true
                  @index += match_len
                else
                  terminal_parse_failure('"Ô"')
                  r19 = nil
                end
                if r19
                  r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
                  r14 = r19
                else
                  if (match_len = has_terminal?("Š", false, index))
                    r20 = true
                    @index += match_len
                  else
                    terminal_parse_failure('"Š"')
                    r20 = nil
                  end
                  if r20
                    r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
                    r14 = r20
                  else
                    if (match_len = has_terminal?("Ś", false, index))
                      r21 = true
                      @index += match_len
                    else
                      terminal_parse_failure('"Ś"')
                      r21 = nil
                    end
                    if r21
                      r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
                      r14 = r21
                    else
                      if (match_len = has_terminal?("Č", false, index))
                        r22 = true
                        @index += match_len
                      else
                        terminal_parse_failure('"Č"')
                        r22 = nil
                      end
                      if r22
                        r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
                        r14 = r22
                      else
                        if (match_len = has_terminal?("Ķ", false, index))
                          r23 = true
                          @index += match_len
                        else
                          terminal_parse_failure('"Ķ"')
                          r23 = nil
                        end
                        if r23
                          r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
                          r14 = r23
                        else
                          if (match_len = has_terminal?("Ł", false, index))
                            r24 = true
                            @index += match_len
                          else
                            terminal_parse_failure('"Ł"')
                            r24 = nil
                          end
                          if r24
                            r24 = SyntaxNode.new(input, (index-1)...index) if r24 == true
                            r14 = r24
                          else
                            if (match_len = has_terminal?("É", false, index))
                              r25 = true
                              @index += match_len
                            else
                              terminal_parse_failure('"É"')
                              r25 = nil
                            end
                            if r25
                              r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
                              r14 = r25
                            else
                              if (match_len = has_terminal?("Ž", false, index))
                                r26 = true
                                @index += match_len
                              else
                                terminal_parse_failure('"Ž"')
                                r26 = nil
                              end
                              if r26
                                r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
                                r14 = r26
                              else
                                if has_terminal?(@regexps[gr = '\A[A-W]'] ||= Regexp.new(gr), :regexp, index)
                                  r27 = true
                                  @index += 1
                                else
                                  terminal_parse_failure('[A-W]')
                                  r27 = nil
                                end
                                if r27
                                  r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
                                  r14 = r27
                                else
                                  if has_terminal?(@regexps[gr = '\A[Y-Z]'] ||= Regexp.new(gr), :regexp, index)
                                    r28 = true
                                    @index += 1
                                  else
                                    terminal_parse_failure('[Y-Z]')
                                    r28 = nil
                                  end
                                  if r28
                                    r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
                                    r14 = r28
                                  else
                                    @index = i14
                                    r14 = nil
                                  end
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
        s9 << r14
        if r14
          s29, i29 = [], index
          loop do
            if has_terminal?(@regexps[gr = '\A[^0-9\\[\\]\\(\\)\\s&,]'] ||= Regexp.new(gr), :regexp, index)
              r30 = true
              @index += 1
            else
              terminal_parse_failure('[^0-9\\[\\]\\(\\)\\s&,]')
              r30 = nil
            end
            if r30
              s29 << r30
            else
              break
            end
          end
          r29 = instantiate_node(SyntaxNode,input, i29...index, s29)
          s9 << r29
        end
      end
      if s9.last
        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
        r9.extend(AuthorWord3)
        r9.extend(AuthorWord4)
      else
        @index = i9
        r9 = nil
      end
      if r9
        r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
        r0 = r9
      else
        i31, s31 = index, []
        if (match_len = has_terminal?("X", false, index))
          r32 = true
          @index += match_len
        else
          terminal_parse_failure('"X"')
          r32 = nil
        end
        s31 << r32
        if r32
          s33, i33 = [], index
          loop do
            if has_terminal?(@regexps[gr = '\A[^0-9\\[\\]\\(\\)\\s&,]'] ||= Regexp.new(gr), :regexp, index)
              r34 = true
              @index += 1
            else
              terminal_parse_failure('[^0-9\\[\\]\\(\\)\\s&,]')
              r34 = nil
            end
            if r34
              s33 << r34
            else
              break
            end
          end
          if s33.empty?
            @index = i33
            r33 = nil
          else
            r33 = instantiate_node(SyntaxNode,input, i33...index, s33)
          end
          s31 << r33
        end
        if s31.last
          r31 = instantiate_node(SyntaxNode,input, i31...index, s31)
          r31.extend(AuthorWord5)
          r31.extend(AuthorWord6)
        else
          @index = i31
          r31 = nil
        end
        if r31
          r31 = SyntaxNode.new(input, (index-1)...index) if r31 == true
          r0 = r31
        else
          r35 = _nt_author_prefix_word
          if r35
            r35 = SyntaxNode.new(input, (index-1)...index) if r35 == true
            r0 = r35
          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 5200

def _nt_authors_names
  start_index = index
  if node_cache[:authors_names].has_key?(index)
    cached = node_cache[:authors_names][index]
    if cached
      node_cache[:authors_names][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r7 = _nt_author_name
    if r7
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      r0 = r7
    else
      r8 = _nt_unknown_auth
      if r8
        r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
        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 3978

def _nt_authorship
  start_index = index
  if node_cache[:authorship].has_key?(index)
    cached = node_cache[:authorship][index]
    if cached
      node_cache[:authorship][index] = 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 (match_len = has_terminal?(",", false, index))
          r6 = true
          @index += match_len
        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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    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
        if r12
          r13 = _nt_space
          s9 << r13
          if r13
            r14 = _nt_emend_authorship
            s9 << r14
          end
        end
      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
      r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
      r0 = r9
    else
      i15, s15 = index, []
      r16 = _nt_basionym_authorship_with_parenthesis
      s15 << r16
      if r16
        r17 = _nt_space
        s15 << r17
        if r17
          r18 = _nt_simple_authorship
          s15 << r18
        end
      end
      if s15.last
        r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
        r15.extend(Authorship4)
        r15.extend(Authorship5)
      else
        @index = i15
        r15 = nil
      end
      if r15
        r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
        r0 = r15
      else
        r19 = _nt_basionym_authorship_with_parenthesis
        if r19
          r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
          r0 = r19
        else
          i20, s20 = index, []
          r21 = _nt_simple_authorship
          s20 << r21
          if r21
            if (match_len = has_terminal?(",", false, index))
              r23 = true
              @index += match_len
            else
              terminal_parse_failure('","')
              r23 = nil
            end
            if r23
              r22 = r23
            else
              r22 = instantiate_node(SyntaxNode,input, index...index)
            end
            s20 << r22
            if r22
              r24 = _nt_space
              s20 << r24
              if r24
                r25 = _nt_ex_authorship
                s20 << r25
              end
            end
          end
          if s20.last
            r20 = instantiate_node(SyntaxNode,input, i20...index, s20)
            r20.extend(Authorship6)
            r20.extend(Authorship7)
          else
            @index = i20
            r20 = nil
          end
          if r20
            r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
            r0 = r20
          else
            i26, s26 = index, []
            r27 = _nt_simple_authorship
            s26 << r27
            if r27
              r28 = _nt_space
              s26 << r28
              if r28
                r29 = _nt_emend_authorship
                s26 << r29
              end
            end
            if s26.last
              r26 = instantiate_node(SyntaxNode,input, i26...index, s26)
              r26.extend(Authorship8)
              r26.extend(Authorship9)
            else
              @index = i26
              r26 = nil
            end
            if r26
              r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
              r0 = r26
            else
              r30 = _nt_simple_authorship
              if r30
                r30 = SyntaxNode.new(input, (index-1)...index) if r30 == true
                r0 = r30
              else
                @index = i0
                r0 = nil
              end
            end
          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 4394

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
      node_cache[:basionym_authorship_with_parenthesis][index] = 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?(@regexps[gr = '\A[,]'] ||= Regexp.new(gr), :regexp, index)
                r9 = true
                @index += 1
              else
                terminal_parse_failure('[,]')
                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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    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 (match_len = has_terminal?(",", false, index))
            r17 = true
            @index += match_len
          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
      r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
      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_emend_authorship
              s22 << r27
              if r27
                r28 = _nt_space
                s22 << r28
                if r28
                  r29 = _nt_right_paren
                  s22 << r29
                end
              end
            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
        r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
        r0 = r22
      else
        i30, s30 = index, []
        r31 = _nt_left_paren
        s30 << r31
        if r31
          r32 = _nt_space
          s30 << r32
          if r32
            r33 = _nt_simple_authorship
            s30 << r33
            if r33
              r34 = _nt_space
              s30 << r34
              if r34
                r35 = _nt_right_paren
                s30 << r35
              end
            end
          end
        end
        if s30.last
          r30 = instantiate_node(SyntaxNode,input, i30...index, s30)
          r30.extend(BasionymAuthorshipWithParenthesis6)
          r30.extend(BasionymAuthorshipWithParenthesis7)
        else
          @index = i30
          r30 = nil
        end
        if r30
          r30 = SyntaxNode.new(input, (index-1)...index) if r30 == true
          r0 = r30
        else
          i36, s36 = index, []
          r37 = _nt_left_paren
          s36 << r37
          if r37
            r38 = _nt_space
            s36 << r38
            if r38
              if (match_len = has_terminal?("?", false, index))
                r39 = true
                @index += match_len
              else
                terminal_parse_failure('"?"')
                r39 = nil
              end
              s36 << r39
              if r39
                r40 = _nt_space
                s36 << r40
                if r40
                  r41 = _nt_right_paren
                  s36 << r41
                end
              end
            end
          end
          if s36.last
            r36 = instantiate_node(SyntaxNode,input, i36...index, s36)
            r36.extend(BasionymAuthorshipWithParenthesis8)
            r36.extend(BasionymAuthorshipWithParenthesis9)
          else
            @index = i36
            r36 = nil
          end
          if r36
            r36 = SyntaxNode.new(input, (index-1)...index) if r36 == true
            r0 = r36
          else
            @index = i0
            r0 = nil
          end
        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 8398

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

  i0 = index
  if (match_len = has_terminal?("Æ", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r1.extend(CapDigraph0)
    @index += match_len
  else
    terminal_parse_failure('"Æ"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("Œ", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      r2.extend(CapDigraph1)
      @index += match_len
    else
      terminal_parse_failure('"Œ"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      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 7032

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
      node_cache[:cap_latin_word][index] = 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?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
    r3 = true
    @index += 1
  else
    terminal_parse_failure('[A-Z]')
    r3 = nil
  end
  if r3
    r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
    r2 = r3
  else
    r4 = _nt_cap_digraph
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r2 = r4
    else
      @index = i2
      r2 = nil
    end
  end
  s1 << r2
  if r2
    r5 = _nt_latin_word
    s1 << r5
    if r5
      if (match_len = has_terminal?("?", false, index))
        r6 = true
        @index += match_len
      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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i7, s7 = index, []
    i8 = index
    if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
      r9 = true
      @index += 1
    else
      terminal_parse_failure('[A-Z]')
      r9 = nil
    end
    if r9
      r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
      r8 = r9
    else
      r10 = _nt_cap_digraph
      if r10
        r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
        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
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      r0 = r7
    else
      i12, s12 = index, []
      i13 = index
      if (match_len = has_terminal?("AE", false, index))
        r14 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"AE"')
        r14 = nil
      end
      if r14
        r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
        r13 = r14
      else
        if (match_len = has_terminal?("OE", false, index))
          r15 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"OE"')
          r15 = nil
        end
        if r15
          r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
          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
        r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
        r0 = r12
      else
        i17 = index
        if (match_len = has_terminal?("Ca", false, index))
          r18 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"Ca"')
          r18 = nil
        end
        if r18
          r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
          r17 = r18
          r17.extend(CapLatinWord6)
          r17.extend(CapLatinWord6)
        else
          if (match_len = has_terminal?("Ea", false, index))
            r19 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"Ea"')
            r19 = nil
          end
          if r19
            r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
            r17 = r19
            r17.extend(CapLatinWord6)
            r17.extend(CapLatinWord6)
          else
            if (match_len = has_terminal?("Ge", false, index))
              r20 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"Ge"')
              r20 = nil
            end
            if r20
              r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
              r17 = r20
              r17.extend(CapLatinWord6)
              r17.extend(CapLatinWord6)
            else
              if (match_len = has_terminal?("Ia", false, index))
                r21 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"Ia"')
                r21 = nil
              end
              if r21
                r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
                r17 = r21
                r17.extend(CapLatinWord6)
                r17.extend(CapLatinWord6)
              else
                if (match_len = has_terminal?("Io", false, index))
                  r22 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"Io"')
                  r22 = nil
                end
                if r22
                  r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
                  r17 = r22
                  r17.extend(CapLatinWord6)
                  r17.extend(CapLatinWord6)
                else
                  if (match_len = has_terminal?("Io", false, index))
                    r23 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                    @index += match_len
                  else
                    terminal_parse_failure('"Io"')
                    r23 = nil
                  end
                  if r23
                    r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
                    r17 = r23
                    r17.extend(CapLatinWord6)
                    r17.extend(CapLatinWord6)
                  else
                    if (match_len = has_terminal?("Ix", false, index))
                      r24 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                      @index += match_len
                    else
                      terminal_parse_failure('"Ix"')
                      r24 = nil
                    end
                    if r24
                      r24 = SyntaxNode.new(input, (index-1)...index) if r24 == true
                      r17 = r24
                      r17.extend(CapLatinWord6)
                      r17.extend(CapLatinWord6)
                    else
                      if (match_len = has_terminal?("Lo", false, index))
                        r25 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                        @index += match_len
                      else
                        terminal_parse_failure('"Lo"')
                        r25 = nil
                      end
                      if r25
                        r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
                        r17 = r25
                        r17.extend(CapLatinWord6)
                        r17.extend(CapLatinWord6)
                      else
                        if (match_len = has_terminal?("Oa", false, index))
                          r26 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                          @index += match_len
                        else
                          terminal_parse_failure('"Oa"')
                          r26 = nil
                        end
                        if r26
                          r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
                          r17 = r26
                          r17.extend(CapLatinWord6)
                          r17.extend(CapLatinWord6)
                        else
                          if (match_len = has_terminal?("Ra", false, index))
                            r27 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"Ra"')
                            r27 = nil
                          end
                          if r27
                            r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
                            r17 = r27
                            r17.extend(CapLatinWord6)
                            r17.extend(CapLatinWord6)
                          else
                            if (match_len = has_terminal?("Ty", false, index))
                              r28 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                              @index += match_len
                            else
                              terminal_parse_failure('"Ty"')
                              r28 = nil
                            end
                            if r28
                              r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
                              r17 = r28
                              r17.extend(CapLatinWord6)
                              r17.extend(CapLatinWord6)
                            else
                              if (match_len = has_terminal?("Ua", false, index))
                                r29 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                @index += match_len
                              else
                                terminal_parse_failure('"Ua"')
                                r29 = nil
                              end
                              if r29
                                r29 = SyntaxNode.new(input, (index-1)...index) if r29 == true
                                r17 = r29
                                r17.extend(CapLatinWord6)
                                r17.extend(CapLatinWord6)
                              else
                                if (match_len = has_terminal?("Aa", false, index))
                                  r30 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                  @index += match_len
                                else
                                  terminal_parse_failure('"Aa"')
                                  r30 = nil
                                end
                                if r30
                                  r30 = SyntaxNode.new(input, (index-1)...index) if r30 == true
                                  r17 = r30
                                  r17.extend(CapLatinWord6)
                                  r17.extend(CapLatinWord6)
                                else
                                  if (match_len = has_terminal?("Ja", false, index))
                                    r31 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                    @index += match_len
                                  else
                                    terminal_parse_failure('"Ja"')
                                    r31 = nil
                                  end
                                  if r31
                                    r31 = SyntaxNode.new(input, (index-1)...index) if r31 == true
                                    r17 = r31
                                    r17.extend(CapLatinWord6)
                                    r17.extend(CapLatinWord6)
                                  else
                                    if (match_len = has_terminal?("Zu", false, index))
                                      r32 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                      @index += match_len
                                    else
                                      terminal_parse_failure('"Zu"')
                                      r32 = nil
                                    end
                                    if r32
                                      r32 = SyntaxNode.new(input, (index-1)...index) if r32 == true
                                      r17 = r32
                                      r17.extend(CapLatinWord6)
                                      r17.extend(CapLatinWord6)
                                    else
                                      if (match_len = has_terminal?("La", false, index))
                                        r33 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                        @index += match_len
                                      else
                                        terminal_parse_failure('"La"')
                                        r33 = nil
                                      end
                                      if r33
                                        r33 = SyntaxNode.new(input, (index-1)...index) if r33 == true
                                        r17 = r33
                                        r17.extend(CapLatinWord6)
                                        r17.extend(CapLatinWord6)
                                      else
                                        if (match_len = has_terminal?("Qu", false, index))
                                          r34 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                          @index += match_len
                                        else
                                          terminal_parse_failure('"Qu"')
                                          r34 = nil
                                        end
                                        if r34
                                          r34 = SyntaxNode.new(input, (index-1)...index) if r34 == true
                                          r17 = r34
                                          r17.extend(CapLatinWord6)
                                          r17.extend(CapLatinWord6)
                                        else
                                          if (match_len = has_terminal?("As", false, index))
                                            r35 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                            @index += match_len
                                          else
                                            terminal_parse_failure('"As"')
                                            r35 = nil
                                          end
                                          if r35
                                            r35 = SyntaxNode.new(input, (index-1)...index) if r35 == true
                                            r17 = r35
                                            r17.extend(CapLatinWord6)
                                            r17.extend(CapLatinWord6)
                                          else
                                            if (match_len = has_terminal?("Ba", false, index))
                                              r36 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                              @index += match_len
                                            else
                                              terminal_parse_failure('"Ba"')
                                              r36 = nil
                                            end
                                            if r36
                                              r36 = SyntaxNode.new(input, (index-1)...index) if r36 == true
                                              r17 = r36
                                              r17.extend(CapLatinWord6)
                                              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
          r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
          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 6935

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
      node_cache[:cap_latin_word_pair][index] = 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 (match_len = has_terminal?("-", false, index))
      r2 = true
      @index += match_len
    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 7471

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
      node_cache[:capped_dotted_char][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[A-Z]')
    r1 = nil
  end
  s0 << r1
  if r1
    if (match_len = has_terminal?(".", false, index))
      r2 = true
      @index += match_len
    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_emend ⇒ `Object`

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

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

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?("emend.", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"emend."')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("emend", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"emend"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      @index = i1
      r1 = nil
    end
  end
  s0 << r1
  if r1
    i4 = index
    if has_terminal?(@regexps[gr = '\A[\\s]'] ||= Regexp.new(gr), :regexp, index)
      r5 = true
      @index += 1
    else
      terminal_parse_failure('[\\s]')
      r5 = nil
    end
    if r5
      @index = i4
      r4 = instantiate_node(SyntaxNode,input, index...index)
    else
      @index = i4
      r4 = nil
    end
    s0 << r4
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Emend0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:emend][start_index] = r0

  r0
end

#_nt_emend_authorship ⇒ `Object`

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

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

  i0, s0 = index, []
  r1 = _nt_emend
  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(EmendAuthorship0)
    r0.extend(EmendAuthorship1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:emend_authorship][start_index] = r0

  r0
end

#_nt_ex_authorship ⇒ `Object`

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

def _nt_ex_authorship
  start_index = index
  if node_cache[:ex_authorship].has_key?(index)
    cached = node_cache[:ex_authorship][index]
    if cached
      node_cache[:ex_authorship][index] = 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_ex_sep
  s1 << r2
  if r2
    r3 = _nt_space
    s1 << r3
    if r3
      r4 = _nt_simple_authorship
      s1 << r4
      if r4
        r5 = _nt_space
        s1 << r5
        if r5
          r6 = _nt_ex_sep
          s1 << r6
          if r6
            r7 = _nt_space
            s1 << r7
            if r7
              r8 = _nt_simple_authorship
              s1 << r8
            end
          end
        end
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(ExAuthorship0)
    r1.extend(ExAuthorship1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i9, s9 = index, []
    r10 = _nt_ex_sep
    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(ExAuthorship2)
      r9.extend(ExAuthorship3)
    else
      @index = i9
      r9 = nil
    end
    if r9
      r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
      r0 = r9
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:ex_authorship][start_index] = r0

  r0
end

#_nt_ex_sep ⇒ `Object`

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

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

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?("ex", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"ex"')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("in", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"in"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      @index = i1
      r1 = nil
    end
  end
  s0 << r1
  if r1
    i4 = index
    if has_terminal?(@regexps[gr = '\A[\\s]'] ||= Regexp.new(gr), :regexp, index)
      r5 = true
      @index += 1
    else
      terminal_parse_failure('[\\s]')
      r5 = nil
    end
    if r5
      @index = i4
      r4 = instantiate_node(SyntaxNode,input, index...index)
    else
      @index = i4
      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 3357

def _nt_genus
  start_index = index
  if node_cache[:genus].has_key?(index)
    cached = node_cache[:genus][index]
    if cached
      node_cache[:genus][index] = 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
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    r3 = _nt_uninomial_string
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      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
      @index = i4
      r4 = nil
      terminal_parse_failure("<a sequence>", true)
    else
      @terminal_failures.pop
      @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 8799

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

  i0 = index
  i1 = index
  if (match_len = has_terminal?("x", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"x"')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
    r1.extend(HybridCharacter0)
    r1.extend(HybridCharacter0)
  else
    if (match_len = has_terminal?("X", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"X"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
      r1.extend(HybridCharacter0)
      r1.extend(HybridCharacter0)
    else
      @index = i1
      r1 = nil
    end
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r4 = _nt_multiplication_sign
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      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 3256

def _nt_infragenus
  start_index = index
  if node_cache[:infragenus].has_key?(index)
    cached = node_cache[:infragenus][index]
    if cached
      node_cache[:infragenus][index] = 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
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r3 = r4
      else
        r5 = _nt_capped_dotted_char
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          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 1734

def _nt_infraspecies
  start_index = index
  if node_cache[:infraspecies].has_key?(index)
    cached = node_cache[:infraspecies][index]
    if cached
      node_cache[:infraspecies][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_infraspecies_string
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      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 1650

def _nt_infraspecies_mult
  start_index = index
  if node_cache[:infraspecies_mult].has_key?(index)
    cached = node_cache[:infraspecies_mult][index]
    if cached
      node_cache[:infraspecies_mult][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_infraspecies
    r5.extend(InfraspeciesMult2)
    r5.extend(InfraspeciesMult2)
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      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 1879

def _nt_infraspecies_string
  start_index = index
  if node_cache[:infraspecies_string].has_key?(index)
    cached = node_cache[:infraspecies_string][index]
    if cached
      node_cache[:infraspecies_string][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    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?(@regexps[gr = '\A[\\.]'] ||= Regexp.new(gr), :regexp, index)
            r10 = true
            @index += 1
          else
            terminal_parse_failure('[\\.]')
            r10 = nil
          end
          if r10
            @index = i9
            r9 = nil
            terminal_parse_failure('[\\.]', true)
          else
            @terminal_failures.pop
            @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
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      r0 = r5
    else
      i11, s11 = index, []
      r12 = _nt_species_word
      s11 << r12
      if r12
        i13 = index
        if has_terminal?(@regexps[gr = '\A[\\.]'] ||= Regexp.new(gr), :regexp, index)
          r14 = true
          @index += 1
        else
          terminal_parse_failure('[\\.]')
          r14 = nil
        end
        if r14
          @index = i13
          r13 = nil
          terminal_parse_failure('[\\.]', true)
        else
          @terminal_failures.pop
          @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
        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
        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 8195

def _nt_latin_word
  start_index = index
  if node_cache[:latin_word].has_key?(index)
    cached = node_cache[:latin_word][index]
    if cached
      node_cache[:latin_word][index] = 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 (match_len = has_terminal?("-", false, index))
      r3 = true
      @index += match_len
    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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i5, s5 = index, []
    r6 = _nt_valid_name_letter
    s5 << r6
    if r6
      if (match_len = has_terminal?("'", false, index))
        r7 = true
        @index += match_len
      else
        terminal_parse_failure('"\'"')
        r7 = nil
      end
      s5 << r7
      if r7
        r8 = _nt_latin_word
        s5 << r8
      end
    end
    if s5.last
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
      r5.extend(LatinWord2)
      r5.extend(LatinWord3)
    else
      @index = i5
      r5 = nil
    end
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      r0 = r5
    else
      i9, s9 = index, []
      r10 = _nt_valid_name_letter
      s9 << r10
      if r10
        r11 = _nt_valid_name_letters
        s9 << r11
      end
      if s9.last
        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
        r9.extend(LatinWord4)
        r9.extend(LatinWord5)
      else
        @index = i9
        r9 = nil
      end
      if r9
        r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
        r0 = r9
      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 8745

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

  if (match_len = has_terminal?("(", false, index))
    r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  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 1224

def _nt_multinomial_name
  start_index = index
  if node_cache[:multinomial_name].has_key?(index)
    cached = node_cache[:multinomial_name][index]
    if cached
      node_cache[:multinomial_name][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    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
      r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
      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
        r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
        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
          r34 = SyntaxNode.new(input, (index-1)...index) if r34 == true
          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
            r43 = SyntaxNode.new(input, (index-1)...index) if r43 == true
            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
              r50 = SyntaxNode.new(input, (index-1)...index) if r50 == true
              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 8867

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

  i0 = index
  if (match_len = has_terminal?("×", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"×"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(MultiplicationSign0)
    r0.extend(MultiplicationSign0)
  else
    if (match_len = has_terminal?("*", false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('"*"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
      r0.extend(MultiplicationSign0)
      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 1562

def _nt_multiuninomial_name
  start_index = index
  if node_cache[:multiuninomial_name].has_key?(index)
    cached = node_cache[:multiuninomial_name][index]
    if cached
      node_cache[:multiuninomial_name][index] = 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 2086

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

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

  node_cache[:rank][start_index] = r0

  r0
end

#_nt_rank_uninomial ⇒ `Object`

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

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

  i0 = index
  if (match_len = has_terminal?("sect.", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"sect."')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(RankUninomial0)
    r0.extend(RankUninomial0)
  else
    if (match_len = has_terminal?("sect ", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"sect "')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
      r0.extend(RankUninomial0)
      r0.extend(RankUninomial0)
    else
      if (match_len = has_terminal?("subsect.", false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"subsect."')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
        r0.extend(RankUninomial0)
        r0.extend(RankUninomial0)
      else
        if (match_len = has_terminal?("subsect ", false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"subsect "')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
          r0.extend(RankUninomial0)
          r0.extend(RankUninomial0)
        else
          if (match_len = has_terminal?("trib.", false, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"trib."')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
            r0.extend(RankUninomial0)
            r0.extend(RankUninomial0)
          else
            if (match_len = has_terminal?("trib ", false, index))
              r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"trib "')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
              r0.extend(RankUninomial0)
              r0.extend(RankUninomial0)
            else
              if (match_len = has_terminal?("subtrib.", false, index))
                r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"subtrib."')
                r7 = nil
              end
              if r7
                r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                r0 = r7
                r0.extend(RankUninomial0)
                r0.extend(RankUninomial0)
              else
                if (match_len = has_terminal?("subtrib ", false, index))
                  r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"subtrib "')
                  r8 = nil
                end
                if r8
                  r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                  r0 = r8
                  r0.extend(RankUninomial0)
                  r0.extend(RankUninomial0)
                else
                  if (match_len = has_terminal?("ser.", false, index))
                    r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                    @index += match_len
                  else
                    terminal_parse_failure('"ser."')
                    r9 = nil
                  end
                  if r9
                    r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                    r0 = r9
                    r0.extend(RankUninomial0)
                    r0.extend(RankUninomial0)
                  else
                    if (match_len = has_terminal?("ser ", false, index))
                      r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                      @index += match_len
                    else
                      terminal_parse_failure('"ser "')
                      r10 = nil
                    end
                    if r10
                      r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                      r0 = r10
                      r0.extend(RankUninomial0)
                      r0.extend(RankUninomial0)
                    else
                      if (match_len = has_terminal?("subgen.", false, index))
                        r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                        @index += match_len
                      else
                        terminal_parse_failure('"subgen."')
                        r11 = nil
                      end
                      if r11
                        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
                        r0 = r11
                        r0.extend(RankUninomial0)
                        r0.extend(RankUninomial0)
                      else
                        if (match_len = has_terminal?("subgen ", false, index))
                          r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                          @index += match_len
                        else
                          terminal_parse_failure('"subgen "')
                          r12 = nil
                        end
                        if r12
                          r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                          r0 = r12
                          r0.extend(RankUninomial0)
                          r0.extend(RankUninomial0)
                        else
                          if (match_len = has_terminal?("fam.", false, index))
                            r13 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"fam."')
                            r13 = nil
                          end
                          if r13
                            r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
                            r0 = r13
                            r0.extend(RankUninomial0)
                            r0.extend(RankUninomial0)
                          else
                            if (match_len = has_terminal?("fam ", false, index))
                              r14 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                              @index += match_len
                            else
                              terminal_parse_failure('"fam "')
                              r14 = nil
                            end
                            if r14
                              r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
                              r0 = r14
                              r0.extend(RankUninomial0)
                              r0.extend(RankUninomial0)
                            else
                              if (match_len = has_terminal?("subfam.", false, index))
                                r15 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                @index += match_len
                              else
                                terminal_parse_failure('"subfam."')
                                r15 = nil
                              end
                              if r15
                                r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
                                r0 = r15
                                r0.extend(RankUninomial0)
                                r0.extend(RankUninomial0)
                              else
                                if (match_len = has_terminal?("subfam ", false, index))
                                  r16 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                  @index += match_len
                                else
                                  terminal_parse_failure('"subfam "')
                                  r16 = nil
                                end
                                if r16
                                  r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
                                  r0 = r16
                                  r0.extend(RankUninomial0)
                                  r0.extend(RankUninomial0)
                                else
                                  if (match_len = has_terminal?("supertrib.", false, index))
                                    r17 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                    @index += match_len
                                  else
                                    terminal_parse_failure('"supertrib."')
                                    r17 = nil
                                  end
                                  if r17
                                    r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
                                    r0 = r17
                                    r0.extend(RankUninomial0)
                                    r0.extend(RankUninomial0)
                                  else
                                    if (match_len = has_terminal?("supertrib ", false, index))
                                      r18 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                      @index += match_len
                                    else
                                      terminal_parse_failure('"supertrib "')
                                      r18 = nil
                                    end
                                    if r18
                                      r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
                                      r0 = r18
                                      r0.extend(RankUninomial0)
                                      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 8769

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

  if (match_len = has_terminal?(")", false, index))
    r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  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
      node_cache[:root][index] = 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 626

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
      node_cache[:scientific_name_1][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_multinomial_name
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_uninomial_name
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        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 576

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
      node_cache[:scientific_name_2][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_scientific_name_1
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      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 490

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
      node_cache[:scientific_name_3][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_scientific_name_2
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      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 353

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
      node_cache[:scientific_name_4][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    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?(@regexps[gr = '\A[\\?]'] ||= Regexp.new(gr), :regexp, index)
              r13 = true
              @index += 1
            else
              terminal_parse_failure('[\\?]')
              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
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      r0 = r7
    else
      r14 = _nt_scientific_name_3
      if r14
        r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
        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
      node_cache[:scientific_name_5][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    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
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      r0 = r7
    else
      r13 = _nt_scientific_name_4
      if r13
        r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
        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 4981

def _nt_simple_authorship
  start_index = index
  if node_cache[:simple_authorship].has_key?(index)
    cached = node_cache[:simple_authorship][index]
    if cached
      node_cache[:simple_authorship][index] = 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?(@regexps[gr = '\A[,]'] ||= Regexp.new(gr), :regexp, index)
        r5 = true
        @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_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?(@regexps[gr = '\A[,]'] ||= Regexp.new(gr), :regexp, index)
              r10 = true
              @index += 1
            else
              terminal_parse_failure('[,]')
              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 (match_len = has_terminal?("non", false, index))
                  r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                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?(@regexps[gr = '\A[,]'] ||= Regexp.new(gr), :regexp, index)
                          r17 = true
                          @index += 1
                        else
                          terminal_parse_failure('[,]')
                          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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i20, s20 = index, []
    r21 = _nt_authors_names
    s20 << r21
    if r21
      r22 = _nt_space
      s20 << r22
      if r22
        if has_terminal?(@regexps[gr = '\A[,]'] ||= Regexp.new(gr), :regexp, index)
          r24 = true
          @index += 1
        else
          terminal_parse_failure('[,]')
          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
      r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
      r0 = r20
    else
      r27 = _nt_authors_names
      r27.extend(SimpleAuthorship4)
      r27.extend(SimpleAuthorship4)
      if r27
        r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
        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 8915

def _nt_space
  start_index = index
  if node_cache[:space].has_key?(index)
    cached = node_cache[:space][index]
    if cached
      node_cache[:space][index] = 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?(@regexps[gr = '\A[\\s]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[\\s]')
      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 8948

def _nt_space_hard
  start_index = index
  if node_cache[:space_hard].has_key?(index)
    cached = node_cache[:space_hard][index]
    if cached
      node_cache[:space_hard][index] = 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?(@regexps[gr = '\A[\\s]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[\\s]')
      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 3114

def _nt_species
  start_index = index
  if node_cache[:species].has_key?(index)
    cached = node_cache[:species][index]
    if cached
      node_cache[:species][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_species_string
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      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 3182

def _nt_species_string
  start_index = index
  if node_cache[:species_string].has_key?(index)
    cached = node_cache[:species_string][index]
    if cached
      node_cache[:species_string][index] = 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)
  r1.extend(SpeciesString0)
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_species_word_hybrid
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      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 8066

def _nt_species_word
  start_index = index
  if node_cache[:species_word].has_key?(index)
    cached = node_cache[:species_word][index]
    if cached
      node_cache[:species_word][index] = 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?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
      r3 = true
      @index += 1
    else
      terminal_parse_failure('[0-9]')
      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 (match_len = has_terminal?("-", false, index))
      r5 = true
      @index += match_len
    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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r7 = _nt_latin_word
    if r7
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      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 7623

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
      node_cache[:species_word_hybrid][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i5, s5 = index, []
    if (match_len = has_terminal?("X", false, index))
      r6 = true
      @index += match_len
    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
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      r0 = r5
    else
      i9, s9 = index, []
      if (match_len = has_terminal?("x", false, index))
        r10 = true
        @index += match_len
      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
        r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
        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 687

def _nt_status_part
  start_index = index
  if node_cache[:status_part].has_key?(index)
    cached = node_cache[:status_part][index]
    if cached
      node_cache[:status_part][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_status_word
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      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 753

def _nt_status_word
  start_index = index
  if node_cache[:status_word].has_key?(index)
    cached = node_cache[:status_word][index]
    if cached
      node_cache[:status_word][index] = 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?(@regexps[gr = '\A[\\.]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @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(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 2015

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
      node_cache[:taxon_concept_rank][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?("sec.", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"sec."')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(TaxonConceptRank0)
    r0.extend(TaxonConceptRank0)
  else
    if (match_len = has_terminal?("sensu.", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"sensu."')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
      r0.extend(TaxonConceptRank0)
      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 3652

def _nt_uninomial_name
  start_index = index
  if node_cache[:uninomial_name].has_key?(index)
    cached = node_cache[:uninomial_name][index]
    if cached
      node_cache[:uninomial_name][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    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
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      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
        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
        r0 = r11
      else
        r15 = _nt_uninomial_string
        if r15
          r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
          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 3776

def _nt_uninomial_string
  start_index = index
  if node_cache[:uninomial_string].has_key?(index)
    cached = node_cache[:uninomial_string][index]
    if cached
      node_cache[:uninomial_string][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(UninomialString0)
    r0.extend(UninomialString0)
  else
    r2 = _nt_cap_latin_word
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
      r0.extend(UninomialString0)
      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 5281

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

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?("auct.", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"auct."')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("auct", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"auct"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      if (match_len = has_terminal?("hort.", false, index))
        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"hort."')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r1 = r4
      else
        if (match_len = has_terminal?("hort", false, index))
          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"hort"')
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r1 = r5
        else
          if (match_len = has_terminal?("anon.", false, index))
            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"anon."')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r1 = r6
          else
            if (match_len = has_terminal?("anon", false, index))
              r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"anon"')
              r7 = nil
            end
            if r7
              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
              r1 = r7
            else
              if (match_len = has_terminal?("ht.", false, index))
                r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"ht."')
                r8 = nil
              end
              if r8
                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                r1 = r8
              else
                if (match_len = has_terminal?("ht", false, index))
                  r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"ht"')
                  r9 = nil
                end
                if r9
                  r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                  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
      @index = i10
      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 820

def _nt_unparsed
  start_index = index
  if node_cache[:unparsed].has_key?(index)
    cached = node_cache[:unparsed][index]
    if cached
      node_cache[:unparsed][index] = 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 = true
      @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 8360

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
      node_cache[:valid_name_letter][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[a-zëæœ]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    r0.extend(ValidNameLetter0)
    r0.extend(ValidNameLetter0)
    @index += 1
  else
    terminal_parse_failure('[a-zëæœ]')
    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 8310

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
      node_cache[:valid_name_letters][index] = 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?(@regexps[gr = '\A[a-zëæœ]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[a-zëæœ]')
      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)
    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 8480

def _nt_year
  start_index = index
  if node_cache[:year].has_key?(index)
    cached = node_cache[:year][index]
    if cached
      node_cache[:year][index] = 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
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r4 = r5
      else
        r6 = _nt_year_number
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r9 = _nt_year_number_with_character
    if r9
      r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
      r0 = r9
    else
      r10 = _nt_year_number
      if r10
        r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
        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 8637

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

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[12]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[12]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[7890]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[7890]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[0-9]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        i5, s5 = index, []
        if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
          r6 = true
          @index += 1
        else
          terminal_parse_failure('[0-9]')
          r6 = nil
        end
        s5 << r6
        if r6
          if has_terminal?(@regexps[gr = '\A[\\?]'] ||= Regexp.new(gr), :regexp, index)
            r8 = true
            @index += 1
          else
            terminal_parse_failure('[\\?]')
            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
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r4 = r5
        else
          if (match_len = has_terminal?("?", false, index))
            r9 = true
            @index += match_len
          else
            terminal_parse_failure('"?"')
            r9 = nil
          end
          if r9
            r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
            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 8579

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
      node_cache[:year_number_with_character][index] = 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?(@regexps[gr = '\A[a-zA-Z]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[a-zA-Z]')
      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_filius ⇒ Object

#_nt_author_maybe_filius ⇒ Object

#_nt_author_name ⇒ Object

#_nt_author_name_without_postfix ⇒ 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_emend ⇒ Object

#_nt_emend_authorship ⇒ 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_filius ⇒ `Object`

#_nt_author_maybe_filius ⇒ `Object`

#_nt_author_name ⇒ `Object`

#_nt_author_name_without_postfix ⇒ `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_emend ⇒ `Object`

#_nt_emend_authorship ⇒ `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`