module CORAL

# File lib/coral.rb, line 2376
def _nt_ACHAR
  start_index = index
  if node_cache[:ACHAR].has_key?(index)
    cached = node_cache[:ACHAR][index]
    if cached
      node_cache[:ACHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if has_terminal?(@regexps[gr = '\A[\\ -=]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[\\ -=]')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if has_terminal?(@regexps[gr = '\A[\\?-\\[]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[\\?-\\[]')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if has_terminal?(@regexps[gr = '\A[\\]-~]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[\\]-~]')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if has_terminal?(@regexps[gr = '\A[€-􏿽]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[€-􏿽]')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          r5 = _nt_SESC
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end
  end

  node_cache[:ACHAR][start_index] = r0

  r0
end

# File lib/coral.rb, line 2914
def _nt_ALPHA
  start_index = index
  if node_cache[:ALPHA].has_key?(index)
    cached = node_cache[:ALPHA][index]
    if cached
      node_cache[:ALPHA][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = 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
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if has_terminal?(@regexps[gr = '\A[a-z]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[a-z]')
      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[:ALPHA][start_index] = r0

  r0
end

# File lib/coral.rb, line 2666
def _nt_BCHAR
  start_index = index
  if node_cache[:BCHAR].has_key?(index)
    cached = node_cache[:BCHAR][index]
    if cached
      node_cache[:BCHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if has_terminal?(@regexps[gr = '\A[\\ -&]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[\\ -&]')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if has_terminal?(@regexps[gr = '\A[\\(-\\[]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[\\(-\\[]')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if has_terminal?(@regexps[gr = '\A[\\]-􏿽]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[\\]-􏿽]')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        r4 = _nt_SESC
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          r5 = _nt_CRLF
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end
  end

  node_cache[:BCHAR][start_index] = r0

  r0
end

# File lib/coral.rb, line 3166
def _nt_BINDIG
  start_index = index
  if node_cache[:BINDIG].has_key?(index)
    cached = node_cache[:BINDIG][index]
    if cached
      node_cache[:BINDIG][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[0-1]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[0-1]')
    r0 = nil
  end

  node_cache[:BINDIG][start_index] = r0

  r0
end

# File lib/coral.rb, line 3311
def _nt_COMMENT
  start_index = index
  if node_cache[:COMMENT].has_key?(index)
    cached = node_cache[:COMMENT][index]
    if cached
      node_cache[:COMMENT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("//", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"//"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_PCHAR
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      r4 = _nt_CRLF
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(COMMENT0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:COMMENT][start_index] = r0

  r0
end

# File lib/coral.rb, line 3405
def _nt_CRLF
  start_index = index
  if node_cache[:CRLF].has_key?(index)
    cached = node_cache[:CRLF][index]
    if cached
      node_cache[:CRLF][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?("\n", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"\\n"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("\r\n", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"\\r\\n"')
      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[:CRLF][start_index] = r0

  r0
end

# File lib/coral.rb, line 3020
def _nt_DIGIT
  start_index = index
  if node_cache[:DIGIT].has_key?(index)
    cached = node_cache[:DIGIT][index]
    if cached
      node_cache[:DIGIT][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[0-9]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[0-9]')
    r0 = nil
  end

  node_cache[:DIGIT][start_index] = r0

  r0
end

# File lib/coral.rb, line 3044
def _nt_DIGIT1
  start_index = index
  if node_cache[:DIGIT1].has_key?(index)
    cached = node_cache[:DIGIT1][index]
    if cached
      node_cache[:DIGIT1][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[1-9]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[1-9]')
    r0 = nil
  end

  node_cache[:DIGIT1][start_index] = r0

  r0
end

# File lib/coral.rb, line 2567
def _nt_DOLLAR
  start_index = index
  if node_cache[:DOLLAR].has_key?(index)
    cached = node_cache[:DOLLAR][index]
    if cached
      node_cache[:DOLLAR][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[:DOLLAR][start_index] = r0

  r0
end

# File lib/coral.rb, line 2958
def _nt_EALPHA
  start_index = index
  if node_cache[:EALPHA].has_key?(index)
    cached = node_cache[:EALPHA][index]
    if cached
      node_cache[:EALPHA][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_ALPHA
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  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
    else
      if (match_len = has_terminal?("_", false, index))
        r3 = true
        @index += match_len
      else
        terminal_parse_failure('"_"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?("$", false, index))
          r4 = true
          @index += match_len
        else
          terminal_parse_failure('"$"')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:EALPHA][start_index] = r0

  r0
end

# File lib/coral.rb, line 3068
def _nt_HEXDIG
  start_index = index
  if node_cache[:HEXDIG].has_key?(index)
    cached = node_cache[:HEXDIG][index]
    if cached
      node_cache[:HEXDIG][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_DIGIT
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("a", :insens, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"A"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?("b", :insens, 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
      else
        if (match_len = has_terminal?("c", :insens, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"C"')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          if (match_len = has_terminal?("d", :insens, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"D"')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            if (match_len = has_terminal?("e", :insens, index))
              r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"E"')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
            else
              if (match_len = has_terminal?("f", :insens, index))
                r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"F"')
                r7 = nil
              end
              if r7
                r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                r0 = r7
              else
                @index = i0
                r0 = nil
              end
            end
          end
        end
      end
    end
  end

  node_cache[:HEXDIG][start_index] = r0

  r0
end

# File lib/coral.rb, line 3273
def _nt_NL
  start_index = index
  if node_cache[:NL].has_key?(index)
    cached = node_cache[:NL][index]
    if cached
      node_cache[:NL][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_COMMENT
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_CRLF
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:NL][start_index] = r0

  r0
end

# File lib/coral.rb, line 3361
def _nt_PCHAR
  start_index = index
  if node_cache[:PCHAR].has_key?(index)
    cached = node_cache[:PCHAR][index]
    if cached
      node_cache[:PCHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if has_terminal?(@regexps[gr = '\A[\\ -~]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[\\ -~]')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if has_terminal?(@regexps[gr = '\A[€-􏿽]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    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[:PCHAR][start_index] = r0

  r0
end

# File lib/coral.rb, line 3190
def _nt_S
  start_index = index
  if node_cache[:S].has_key?(index)
    cached = node_cache[:S][index]
    if cached
      node_cache[:S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    r1 = _nt_WS
    if r1
      s0 << r1
    else
      break
    end
  end
  r0 = instantiate_node(SyntaxNode,input, i0...index, s0)

  node_cache[:S][start_index] = r0

  r0
end

# File lib/coral.rb, line 2032
def _nt_SCHAR
  start_index = index
  if node_cache[:SCHAR].has_key?(index)
    cached = node_cache[:SCHAR][index]
    if cached
      node_cache[:SCHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if has_terminal?(@regexps[gr = '\A[\\ -!]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[\\ -!]')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if has_terminal?(@regexps[gr = '\A[\\#-\\[]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[\\#-\\[]')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if has_terminal?(@regexps[gr = '\A[\\]-~]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[\\]-~]')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if has_terminal?(@regexps[gr = '\A[€-􏿽]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[€-􏿽]')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          r5 = _nt_SESC
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end
  end

  node_cache[:SCHAR][start_index] = r0

  r0
end

# File lib/coral.rb, line 2109
def _nt_SESC
  start_index = index
  if node_cache[:SESC].has_key?(index)
    cached = node_cache[:SESC][index]
    if cached
      node_cache[:SESC][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("\\", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"\\\\"')
    r1 = nil
  end
  s0 << r1
  if r1
    i2 = index
    r3 = _nt_hexadecimalescape
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r2 = r3
    else
      r4 = _nt_unicodeescape
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r2 = r4
      else
        i5 = index
        if has_terminal?(@regexps[gr = '\A[\\ -~]'] ||= Regexp.new(gr), :regexp, index)
          r6 = true
          @index += 1
        else
          terminal_parse_failure('[\\ -~]')
          r6 = nil
        end
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          r5 = r6
        else
          if has_terminal?(@regexps[gr = '\A[€-􏿽]'] ||= Regexp.new(gr), :regexp, index)
            r7 = true
            @index += 1
          else
            terminal_parse_failure('[€-􏿽]')
            r7 = nil
          end
          if r7
            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
            r5 = r7
          else
            @index = i5
            r5 = nil
          end
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r2 = r5
        else
          @index = i2
          r2 = nil
        end
      end
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SESC0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:SESC][start_index] = r0

  r0
end

# File lib/coral.rb, line 3249
def _nt_SP
  start_index = index
  if node_cache[:SP].has_key?(index)
    cached = node_cache[:SP][index]
    if cached
      node_cache[:SP][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[:SP][start_index] = r0

  r0
end

# File lib/coral.rb, line 3217
def _nt_WS
  start_index = index
  if node_cache[:WS].has_key?(index)
    cached = node_cache[:WS][index]
    if cached
      node_cache[:WS][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_SP
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_NL
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:WS][start_index] = r0

  r0
end

# File lib/coral.rb, line 2320
def _nt_angled
  start_index = index
  if node_cache[:angled].has_key?(index)
    cached = node_cache[:angled][index]
    if cached
      node_cache[:angled][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("<", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"<"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ACHAR
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if (match_len = has_terminal?(">", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('">"')
        r4 = nil
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Angled0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:angled][start_index] = r0

  r0
end

# File lib/coral.rb, line 1081
def _nt_base
  start_index = index
  if node_cache[:base].has_key?(index)
    cached = node_cache[:base][index]
    if cached
      node_cache[:base][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_iriref

  node_cache[:base][start_index] = r0

  r0
end

# File lib/coral.rb, line 1039
def _nt_basedirective
  start_index = index
  if node_cache[:basedirective].has_key?(index)
    cached = node_cache[:basedirective][index]
    if cached
      node_cache[:basedirective][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("#base", :insens, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"#base"')
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_S
    s0 << r2
    if r2
      r3 = _nt_base
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Basedirective0)
    r0.extend(Basedirective1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:basedirective][start_index] = r0

  r0
end

# File lib/coral.rb, line 31
def _nt_body
  start_index = index
  if node_cache[:body].has_key?(index)
    cached = node_cache[:body][index]
    if cached
      node_cache[:body][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_S
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      i4 = index
      r5 = _nt_link
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r4 = r5
      else
        r6 = _nt_form
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          r4 = r6
        else
          r7 = _nt_representation
          if r7
            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
            r4 = r7
          else
            r8 = _nt_directive
            if r8
              r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
              r4 = r8
            else
              @index = i4
              r4 = nil
            end
          end
        end
      end
      s3 << r4
      if r4
        r9 = _nt_S
        s3 << r9
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(Body0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Body1)
    r0.extend(Body2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:body][start_index] = r0

  r0
end

# File lib/coral.rb, line 1294
def _nt_boolean
  start_index = index
  if node_cache[:boolean].has_key?(index)
    cached = node_cache[:boolean][index]
    if cached
      node_cache[:boolean][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?("true", :insens, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r1.extend(Boolean0)
    @index += match_len
  else
    terminal_parse_failure('"true"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("false", :insens, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      r2.extend(Boolean1)
      @index += match_len
    else
      terminal_parse_failure('"false"')
      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[:boolean][start_index] = r0

  r0
end

# File lib/coral.rb, line 2734
def _nt_bsqual
  start_index = index
  if node_cache[:bsqual].has_key?(index)
    cached = node_cache[:bsqual][index]
    if cached
      node_cache[:bsqual][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?("h", :insens, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"h"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("b16", :insens, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"b16"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?("b32", :insens, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"b32"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?("b64", :insens, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"b64"')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:bsqual][start_index] = r0

  r0
end

# File lib/coral.rb, line 2600
def _nt_bytes
  start_index = index
  if node_cache[:bytes].has_key?(index)
    cached = node_cache[:bytes][index]
    if cached
      node_cache[:bytes][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r2 = _nt_bsqual
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    if (match_len = has_terminal?("'", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"\'"')
      r3 = nil
    end
    s0 << r3
    if r3
      s4, i4 = [], index
      loop do
        r5 = _nt_BCHAR
        if r5
          s4 << r5
        else
          break
        end
      end
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      s0 << r4
      if r4
        if (match_len = has_terminal?("'", false, index))
          r6 = true
          @index += match_len
        else
          terminal_parse_failure('"\'"')
          r6 = nil
        end
        s0 << r6
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Bytes0)
    r0.extend(Bytes1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:bytes][start_index] = r0

  r0
end

# File lib/coral.rb, line 2470
def _nt_datetime
  start_index = index
  if node_cache[:datetime].has_key?(index)
    cached = node_cache[:datetime][index]
    if cached
      node_cache[:datetime][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_DOLLAR
  s0 << r1
  if r1
    r2 = _nt_datetime1
    s0 << r2
    if r2
      r3 = _nt_DOLLAR
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Datetime0)
    r0.extend(Datetime1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:datetime][start_index] = r0

  r0
end

# File lib/coral.rb, line 2512
def _nt_datetime1
  start_index = index
  if node_cache[:datetime1].has_key?(index)
    cached = node_cache[:datetime1][index]
    if cached
      node_cache[:datetime1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    i1 = index
    if has_terminal?(@regexps[gr = '\A[\\ -\\#]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[\\ -\\#]')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r1 = r2
    else
      if has_terminal?(@regexps[gr = '\A[%-~]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[%-~]')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r1 = r3
      else
        @index = i1
        r1 = nil
      end
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  r0.extend(Datetime10)
  r0.extend(Datetime10)

  node_cache[:datetime1][start_index] = r0

  r0
end

# File lib/coral.rb, line 991
def _nt_directive
  start_index = index
  if node_cache[:directive].has_key?(index)
    cached = node_cache[:directive][index]
    if cached
      node_cache[:directive][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_basedirective
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_usingdirective
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:directive][start_index] = r0

  r0
end

# File lib/coral.rb, line 1890
def _nt_exponent
  start_index = index
  if node_cache[:exponent].has_key?(index)
    cached = node_cache[:exponent][index]
    if cached
      node_cache[:exponent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i2 = index
  if (match_len = has_terminal?("+", false, index))
    r3 = true
    @index += match_len
  else
    terminal_parse_failure('"+"')
    r3 = nil
  end
  if r3
    r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
    r2 = r3
  else
    if (match_len = has_terminal?("-", false, index))
      r4 = true
      @index += match_len
    else
      terminal_parse_failure('"-"')
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r2 = r4
    else
      @index = i2
      r2 = nil
    end
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    s5, i5 = [], index
    loop do
      r6 = _nt_DIGIT
      if r6
        s5 << r6
      else
        break
      end
    end
    if s5.empty?
      @index = i5
      r5 = nil
    else
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
    end
    s0 << r5
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Exponent0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:exponent][start_index] = r0

  r0
end

# File lib/coral.rb, line 461
def _nt_form
  start_index = index
  if node_cache[:form].has_key?(index)
    cached = node_cache[:form][index]
    if cached
      node_cache[:form][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_operationtype
  s0 << r1
  if r1
    r2 = _nt_S
    s0 << r2
    if r2
      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
      s0 << r3
      if r3
        r4 = _nt_S
        s0 << r4
        if r4
          r5 = _nt_method
          s0 << r5
          if r5
            r6 = _nt_S
            s0 << r6
            if r6
              r7 = _nt_submissiontarget
              s0 << r7
              if r7
                i9, s9 = index, []
                r10 = _nt_S
                s9 << r10
                if r10
                  if (match_len = has_terminal?("[", false, index))
                    r11 = true
                    @index += match_len
                  else
                    terminal_parse_failure('"["')
                    r11 = nil
                  end
                  s9 << r11
                  if r11
                    r12 = _nt_S
                    s9 << r12
                    if r12
                      r13 = _nt_formfields
                      s9 << r13
                      if r13
                        r14 = _nt_S
                        s9 << r14
                        if r14
                          if (match_len = has_terminal?("]", false, index))
                            r15 = true
                            @index += match_len
                          else
                            terminal_parse_failure('"]"')
                            r15 = nil
                          end
                          s9 << r15
                        end
                      end
                    end
                  end
                end
                if s9.last
                  r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
                  r9.extend(Form0)
                else
                  @index = i9
                  r9 = nil
                end
                if r9
                  r8 = r9
                else
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Form1)
    r0.extend(Form2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:form][start_index] = r0

  r0
end

# File lib/coral.rb, line 647
def _nt_formfields
  start_index = index
  if node_cache[:formfields].has_key?(index)
    cached = node_cache[:formfields][index]
    if cached
      node_cache[:formfields][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    i1, s1 = index, []
    r2 = _nt_formfieldtype
    s1 << r2
    if r2
      r3 = _nt_S
      s1 << r3
      if r3
        r4 = _nt_formfieldvalue
        s1 << r4
        if r4
          r5 = _nt_S
          s1 << r5
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Formfields0)
    else
      @index = i1
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  r0.extend(Formfields1)
  r0.extend(Formfields1)

  node_cache[:formfields][start_index] = r0

  r0
end

# File lib/coral.rb, line 697
def _nt_formfieldtype
  start_index = index
  if node_cache[:formfieldtype].has_key?(index)
    cached = node_cache[:formfieldtype][index]
    if cached
      node_cache[:formfieldtype][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_iqs

  node_cache[:formfieldtype][start_index] = r0

  r0
end

# File lib/coral.rb, line 715
def _nt_formfieldvalue
  start_index = index
  if node_cache[:formfieldvalue].has_key?(index)
    cached = node_cache[:formfieldvalue][index]
    if cached
      node_cache[:formfieldvalue][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_iriref
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_literal
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:formfieldvalue][start_index] = r0

  r0
end

# File lib/coral.rb, line 1855
def _nt_fraction
  start_index = index
  if node_cache[:fraction].has_key?(index)
    cached = node_cache[:fraction][index]
    if cached
      node_cache[:fraction][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    r1 = _nt_DIGIT
    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[:fraction][start_index] = r0

  r0
end

# File lib/coral.rb, line 2198
def _nt_hexadecimalescape
  start_index = index
  if node_cache[:hexadecimalescape].has_key?(index)
    cached = node_cache[:hexadecimalescape][index]
    if cached
      node_cache[:hexadecimalescape][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("x", :insens, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"x"')
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_HEXDIG
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Hexadecimalescape0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:hexadecimalescape][start_index] = r0

  r0
end

# File lib/coral.rb, line 1747
def _nt_hexfloat
  start_index = index
  if node_cache[:hexfloat].has_key?(index)
    cached = node_cache[:hexfloat][index]
    if cached
      node_cache[:hexfloat][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("0x", :insens, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"0x"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_HEXDIG
      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
    s0 << r2
    if r2
      i5, s5 = index, []
      if (match_len = has_terminal?(".", false, index))
        r6 = true
        @index += match_len
      else
        terminal_parse_failure('"."')
        r6 = nil
      end
      s5 << r6
      if r6
        s7, i7 = [], index
        loop do
          r8 = _nt_HEXDIG
          if r8
            s7 << r8
          else
            break
          end
        end
        if s7.empty?
          @index = i7
          r7 = nil
        else
          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        end
        s5 << r7
      end
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(Hexfloat0)
      else
        @index = i5
        r5 = nil
      end
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
      if r4
        if (match_len = has_terminal?("p", :insens, index))
          r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"p"')
          r9 = nil
        end
        s0 << r9
        if r9
          r10 = _nt_exponent
          s0 << r10
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Hexfloat1)
    r0.extend(Hexfloat2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:hexfloat][start_index] = r0

  r0
end

# File lib/coral.rb, line 2812
def _nt_id
  start_index = index
  if node_cache[:id].has_key?(index)
    cached = node_cache[:id][index]
    if cached
      node_cache[:id][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_EALPHA
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      s4, i4 = [], index
      loop do
        i5 = index
        if (match_len = has_terminal?("-", false, index))
          r6 = true
          @index += match_len
        else
          terminal_parse_failure('"-"')
          r6 = nil
        end
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          r5 = r6
        else
          if (match_len = has_terminal?(".", false, index))
            r7 = true
            @index += match_len
          else
            terminal_parse_failure('"."')
            r7 = nil
          end
          if r7
            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
            r5 = r7
          else
            @index = i5
            r5 = nil
          end
        end
        if r5
          s4 << r5
        else
          break
        end
      end
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      s3 << r4
      if r4
        i8 = index
        r9 = _nt_EALPHA
        if r9
          r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
          r8 = r9
        else
          r10 = _nt_DIGIT
          if r10
            r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
            r8 = r10
          else
            @index = i8
            r8 = nil
          end
        end
        s3 << r8
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(Id0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Id1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:id][start_index] = r0

  r0
end

# File lib/coral.rb, line 1266
def _nt_identifier
  start_index = index
  if node_cache[:identifier].has_key?(index)
    cached = node_cache[:identifier][index]
    if cached
      node_cache[:identifier][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_id
  r0.extend(Identifier0)
  r0.extend(Identifier0)

  node_cache[:identifier][start_index] = r0

  r0
end

# File lib/coral.rb, line 1567
def _nt_int
  start_index = index
  if node_cache[:int].has_key?(index)
    cached = node_cache[:int][index]
    if cached
      node_cache[:int][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("-", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"-"')
    r2 = nil
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    r3 = _nt_uint
    s0 << r3
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Int0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:int][start_index] = r0

  r0
end

# File lib/coral.rb, line 255
def _nt_iqs
  start_index = index
  if node_cache[:iqs].has_key?(index)
    cached = node_cache[:iqs][index]
    if cached
      node_cache[:iqs][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_iri
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_qualifiedname
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_simplename
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:iqs][start_index] = r0

  r0
end

# File lib/coral.rb, line 1214
def _nt_iri
  start_index = index
  if node_cache[:iri].has_key?(index)
    cached = node_cache[:iri][index]
    if cached
      node_cache[:iri][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_angled
  r0.extend(Iri0)
  r0.extend(Iri0)

  node_cache[:iri][start_index] = r0

  r0
end

# File lib/coral.rb, line 1240
def _nt_iriref
  start_index = index
  if node_cache[:iriref].has_key?(index)
    cached = node_cache[:iriref][index]
    if cached
      node_cache[:iriref][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_angled
  r0.extend(Iriref0)
  r0.extend(Iriref0)

  node_cache[:iriref][start_index] = r0

  r0
end

# File lib/coral.rb, line 151
def _nt_link
  start_index = index
  if node_cache[:link].has_key?(index)
    cached = node_cache[:link][index]
    if cached
      node_cache[:link][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_relationtype
  s0 << r1
  if r1
    r2 = _nt_S
    s0 << r2
    if r2
      r3 = _nt_linktarget
      s0 << r3
      if r3
        i5, s5 = index, []
        r6 = _nt_S
        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_S
            s5 << r8
            if r8
              r9 = _nt_body
              s5 << r9
              if r9
                r10 = _nt_S
                s5 << r10
                if r10
                  if (match_len = has_terminal?("}", false, index))
                    r11 = true
                    @index += match_len
                  else
                    terminal_parse_failure('"}"')
                    r11 = nil
                  end
                  s5 << r11
                end
              end
            end
          end
        end
        if s5.last
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          r5.extend(Link0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Link1)
    r0.extend(Link2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:link][start_index] = r0

  r0
end

# File lib/coral.rb, line 377
def _nt_linktarget
  start_index = index
  if node_cache[:linktarget].has_key?(index)
    cached = node_cache[:linktarget][index]
    if cached
      node_cache[:linktarget][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_iriref
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_literal
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:linktarget][start_index] = r0

  r0
end

# File lib/coral.rb, line 1346
def _nt_literal
  start_index = index
  if node_cache[:literal].has_key?(index)
    cached = node_cache[:literal][index]
    if cached
      node_cache[:literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1 = index
  r2 = _nt_boolean
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
    r1.extend(Literal0)
    r1.extend(Literal0)
  else
    r3 = _nt_number
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
      r1.extend(Literal0)
      r1.extend(Literal0)
    else
      r4 = _nt_text
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r1 = r4
        r1.extend(Literal0)
        r1.extend(Literal0)
      else
        @index = i1
        r1 = nil
      end
    end
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_datetime
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      r0 = r5
    else
      r6 = _nt_bytes
      if r6
        r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
        r0 = r6
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:literal][start_index] = r0

  r0
end

# File lib/coral.rb, line 941
def _nt_metadataname
  start_index = index
  if node_cache[:metadataname].has_key?(index)
    cached = node_cache[:metadataname][index]
    if cached
      node_cache[:metadataname][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_iqs

  node_cache[:metadataname][start_index] = r0

  r0
end

# File lib/coral.rb, line 959
def _nt_metadatavalue
  start_index = index
  if node_cache[:metadatavalue].has_key?(index)
    cached = node_cache[:metadatavalue][index]
    if cached
      node_cache[:metadatavalue][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_iriref
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_literal
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:metadatavalue][start_index] = r0

  r0
end

# File lib/coral.rb, line 587
def _nt_method
  start_index = index
  if node_cache[:method].has_key?(index)
    cached = node_cache[:method][index]
    if cached
      node_cache[:method][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_identifier

  node_cache[:method][start_index] = r0

  r0
end

# File lib/coral.rb, line 1634
def _nt_number
  start_index = index
  if node_cache[:number].has_key?(index)
    cached = node_cache[:number][index]
    if cached
      node_cache[:number][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_hexfloat
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    r3 = _nt_int
    s2 << r3
    if r3
      i5, s5 = index, []
      if (match_len = has_terminal?(".", false, index))
        r6 = true
        @index += match_len
      else
        terminal_parse_failure('"."')
        r6 = nil
      end
      s5 << r6
      if r6
        r7 = _nt_fraction
        s5 << r7
      end
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(Number0)
      else
        @index = i5
        r5 = nil
      end
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s2 << r4
      if r4
        i9, s9 = index, []
        if (match_len = has_terminal?("e", :insens, index))
          r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"e"')
          r10 = nil
        end
        s9 << r10
        if r10
          r11 = _nt_exponent
          s9 << r11
        end
        if s9.last
          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
          r9.extend(Number1)
        else
          @index = i9
          r9 = nil
        end
        if r9
          r8 = r9
        else
          r8 = instantiate_node(SyntaxNode,input, index...index)
        end
        s2 << r8
      end
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(Number2)
      r2.extend(Number3)
    else
      @index = i2
      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[:number][start_index] = r0

  r0
end

# File lib/coral.rb, line 569
def _nt_operationtype
  start_index = index
  if node_cache[:operationtype].has_key?(index)
    cached = node_cache[:operationtype][index]
    if cached
      node_cache[:operationtype][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_iqs

  node_cache[:operationtype][start_index] = r0

  r0
end

# File lib/coral.rb, line 335
def _nt_qualifiedname
  start_index = index
  if node_cache[:qualifiedname].has_key?(index)
    cached = node_cache[:qualifiedname][index]
    if cached
      node_cache[:qualifiedname][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_identifier
  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_identifier
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Qualifiedname0)
    r0.extend(Qualifiedname1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:qualifiedname][start_index] = r0

  r0
end

# File lib/coral.rb, line 237
def _nt_relationtype
  start_index = index
  if node_cache[:relationtype].has_key?(index)
    cached = node_cache[:relationtype][index]
    if cached
      node_cache[:relationtype][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_iqs

  node_cache[:relationtype][start_index] = r0

  r0
end

# File lib/coral.rb, line 779
def _nt_representation
  start_index = index
  if node_cache[:representation].has_key?(index)
    cached = node_cache[:representation][index]
    if cached
      node_cache[:representation][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("*", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"*"')
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_S
    s0 << r2
    if r2
      r3 = _nt_bytes
      s0 << r3
      if r3
        i5, s5 = index, []
        r6 = _nt_S
        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_S
            s5 << r8
            if r8
              r9 = _nt_representationmetadata
              s5 << r9
              if r9
                if (match_len = has_terminal?("]", false, index))
                  r10 = true
                  @index += match_len
                else
                  terminal_parse_failure('"]"')
                  r10 = nil
                end
                s5 << r10
              end
            end
          end
        end
        if s5.last
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          r5.extend(Representation0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Representation1)
    r0.extend(Representation2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:representation][start_index] = r0

  r0
end

# File lib/coral.rb, line 891
def _nt_representationmetadata
  start_index = index
  if node_cache[:representationmetadata].has_key?(index)
    cached = node_cache[:representationmetadata][index]
    if cached
      node_cache[:representationmetadata][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    i1, s1 = index, []
    r2 = _nt_metadataname
    s1 << r2
    if r2
      r3 = _nt_S
      s1 << r3
      if r3
        r4 = _nt_metadatavalue
        s1 << r4
        if r4
          r5 = _nt_S
          s1 << r5
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Representationmetadata0)
    else
      @index = i1
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  r0.extend(Representationmetadata1)
  r0.extend(Representationmetadata1)

  node_cache[:representationmetadata][start_index] = r0

  r0
end

# File lib/coral.rb, line 299
def _nt_simplename
  start_index = index
  if node_cache[:simplename].has_key?(index)
    cached = node_cache[:simplename][index]
    if cached
      node_cache[:simplename][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_identifier
  r0.extend(Simplename0)
  r0.extend(Simplename0)

  node_cache[:simplename][start_index] = r0

  r0
end

# File lib/coral.rb, line 605
def _nt_submissiontarget
  start_index = index
  if node_cache[:submissiontarget].has_key?(index)
    cached = node_cache[:submissiontarget][index]
    if cached
      node_cache[:submissiontarget][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_iriref

  node_cache[:submissiontarget][start_index] = r0

  r0
end

# File lib/coral.rb, line 1975
def _nt_text
  start_index = index
  if node_cache[:text].has_key?(index)
    cached = node_cache[:text][index]
    if cached
      node_cache[:text][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("\"", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"\\""')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_SCHAR
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if (match_len = has_terminal?("\"", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('"\\""')
        r4 = nil
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Text0)
    r0.extend(Text1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:text][start_index] = r0

  r0
end