# Autogenerated from a Treetop grammar. Edits may be lost.


module Soroban
  include Treetop::Runtime

  def root
    @root ||= :formula
  end

  module Formula0
    def logical
      elements[2]
    end
  end

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

    i0 = index
    i1, s1 = index, []
    if has_terminal?('=', false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('=')
      r2 = nil
    end
    s1 << r2
    if r2
      r4 = _nt_space
      if r4
        r3 = r4
      else
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s1 << r3
      if r3
        r5 = _nt_logical
        s1 << r5
      end
    end
    if s1.last
      r1 = instantiate_node(Formula,input, i1...index, s1)
      r1.extend(Formula0)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      r6 = _nt_string
      if r6
        r0 = r6
      else
        r7 = _nt_number
        if r7
          r0 = r7
        else
          r8 = _nt_boolean
          if r8
            r0 = r8
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end

    node_cache[:formula][start_index] = r0

    r0
  end

  module Logical0
    def and
      elements[3]
    end
  end

  module Logical1
    def and
      elements[0]
    end

  end

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

    i0, s0 = index, []
    r1 = _nt_and
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3, s3 = index, []
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s3 << r4
        if r4
          if has_terminal?('or', false, index)
            r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
            @index += 2
          else
            terminal_parse_failure('or')
            r6 = nil
          end
          s3 << r6
          if r6
            r8 = _nt_space
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s3 << r7
            if r7
              r9 = _nt_and
              s3 << r9
            end
          end
        end
        if s3.last
          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
          r3.extend(Logical0)
        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(Logical1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:logical][start_index] = r0

    r0
  end

  module And0
    def truthval
      elements[3]
    end
  end

  module And1
    def truthval
      elements[0]
    end

  end

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

    i0, s0 = index, []
    r1 = _nt_truthval
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3, s3 = index, []
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s3 << r4
        if r4
          if has_terminal?('and', false, index)
            r6 = instantiate_node(SyntaxNode,input, index...(index + 3))
            @index += 3
          else
            terminal_parse_failure('and')
            r6 = nil
          end
          s3 << r6
          if r6
            r8 = _nt_space
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s3 << r7
            if r7
              r9 = _nt_truthval
              s3 << r9
            end
          end
        end
        if s3.last
          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
          r3.extend(And0)
        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(And1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:and][start_index] = r0

    r0
  end

  module Truthval0
    def logical
      elements[2]
    end

  end

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

    i0 = index
    r1 = _nt_comparison
    if r1
      r0 = r1
    else
      i2, s2 = index, []
      if has_terminal?('(', false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('(')
        r3 = nil
      end
      s2 << r3
      if r3
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s2 << r4
        if r4
          r6 = _nt_logical
          s2 << r6
          if r6
            r8 = _nt_space
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s2 << r7
            if r7
              if has_terminal?(')', false, index)
                r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure(')')
                r9 = nil
              end
              s2 << r9
            end
          end
        end
      end
      if s2.last
        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
        r2.extend(Truthval0)
      else
        @index = i2
        r2 = nil
      end
      if r2
        r0 = r2
      else
        r10 = _nt_boolean
        if r10
          r0 = r10
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:truthval][start_index] = r0

    r0
  end

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

    i0 = index
    if has_terminal?('true', false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
      @index += 4
    else
      terminal_parse_failure('true')
      r1 = nil
    end
    if r1
      r0 = r1
    else
      if has_terminal?('false', false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 5))
        @index += 5
      else
        terminal_parse_failure('false')
        r2 = nil
      end
      if r2
        r0 = r2
      else
        if has_terminal?('TRUE', false, index)
          r3 = instantiate_node(SyntaxNode,input, index...(index + 4))
          @index += 4
        else
          terminal_parse_failure('TRUE')
          r3 = nil
        end
        if r3
          r0 = r3
        else
          if has_terminal?('FALSE', false, index)
            r4 = instantiate_node(SyntaxNode,input, index...(index + 5))
            @index += 5
          else
            terminal_parse_failure('FALSE')
            r4 = nil
          end
          if r4
            r0 = r4
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end

    node_cache[:boolean][start_index] = r0

    r0
  end

  module Comparison0
    def comparator
      elements[1]
    end

    def expression
      elements[3]
    end
  end

  module Comparison1
    def expression
      elements[0]
    end

  end

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

    i0, s0 = index, []
    r1 = _nt_expression
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3, s3 = index, []
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s3 << r4
        if r4
          r6 = _nt_comparator
          s3 << r6
          if r6
            r8 = _nt_space
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s3 << r7
            if r7
              r9 = _nt_expression
              s3 << r9
            end
          end
        end
        if s3.last
          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
          r3.extend(Comparison0)
        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(Comparison1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:comparison][start_index] = r0

    r0
  end

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

    i0 = index
    if has_terminal?('=', false, index)
      r1 = instantiate_node(Equal,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('=')
      r1 = nil
    end
    if r1
      r0 = r1
    else
      if has_terminal?('<>', false, index)
        r2 = instantiate_node(NotEqual,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure('<>')
        r2 = nil
      end
      if r2
        r0 = r2
      else
        if has_terminal?('>=', false, index)
          r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
          @index += 2
        else
          terminal_parse_failure('>=')
          r3 = nil
        end
        if r3
          r0 = r3
        else
          if has_terminal?('<=', false, index)
            r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
            @index += 2
          else
            terminal_parse_failure('<=')
            r4 = nil
          end
          if r4
            r0 = r4
          else
            if has_terminal?('>', false, index)
              r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure('>')
              r5 = nil
            end
            if r5
              r0 = r5
            else
              if has_terminal?('<', false, index)
                r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure('<')
                r6 = nil
              end
              if r6
                r0 = r6
              else
                @index = i0
                r0 = nil
              end
            end
          end
        end
      end
    end

    node_cache[:comparator][start_index] = r0

    r0
  end

  module Expression0
    def additive_operator
      elements[1]
    end

    def multiplicative
      elements[3]
    end
  end

  module Expression1
    def multiplicative
      elements[0]
    end

  end

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

    i0, s0 = index, []
    r1 = _nt_multiplicative
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3, s3 = index, []
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s3 << r4
        if r4
          r6 = _nt_additive_operator
          s3 << r6
          if r6
            r8 = _nt_space
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s3 << r7
            if r7
              r9 = _nt_multiplicative
              s3 << r9
            end
          end
        end
        if s3.last
          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
          r3.extend(Expression0)
        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(Expression1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:expression][start_index] = r0

    r0
  end

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

    i0 = index
    if has_terminal?('+', false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('+')
      r1 = nil
    end
    if r1
      r0 = r1
    else
      if has_terminal?('-', false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('-')
        r2 = nil
      end
      if r2
        r0 = r2
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:additive_operator][start_index] = r0

    r0
  end

  module Multiplicative0
    def multiplicative_operator
      elements[1]
    end

    def value
      elements[3]
    end
  end

  module Multiplicative1
    def value
      elements[0]
    end

  end

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

    i0, s0 = index, []
    r1 = _nt_value
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3, s3 = index, []
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s3 << r4
        if r4
          r6 = _nt_multiplicative_operator
          s3 << r6
          if r6
            r8 = _nt_space
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s3 << r7
            if r7
              r9 = _nt_value
              s3 << r9
            end
          end
        end
        if s3.last
          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
          r3.extend(Multiplicative0)
        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(Multiplicative1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:multiplicative][start_index] = r0

    r0
  end

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

    i0 = index
    if has_terminal?('^', false, index)
      r1 = instantiate_node(Pow,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('^')
      r1 = nil
    end
    if r1
      r0 = r1
    else
      if has_terminal?('*', false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('*')
        r2 = nil
      end
      if r2
        r0 = r2
      else
        if has_terminal?('/', false, index)
          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('/')
          r3 = nil
        end
        if r3
          r0 = r3
        else
          @index = i0
          r0 = nil
        end
      end
    end

    node_cache[:multiplicative_operator][start_index] = r0

    r0
  end

  module Value0
    def expression
      elements[2]
    end

  end

  module Value1
    def value
      elements[1]
    end
  end

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

    i0 = index
    r1 = _nt_function
    if r1
      r0 = r1
    else
      i2, s2 = index, []
      if has_terminal?('(', false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('(')
        r3 = nil
      end
      s2 << r3
      if r3
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s2 << r4
        if r4
          r6 = _nt_expression
          s2 << r6
          if r6
            r8 = _nt_space
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s2 << r7
            if r7
              if has_terminal?(')', false, index)
                r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure(')')
                r9 = nil
              end
              s2 << r9
            end
          end
        end
      end
      if s2.last
        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
        r2.extend(Value0)
      else
        @index = i2
        r2 = nil
      end
      if r2
        r0 = r2
      else
        r10 = _nt_range
        if r10
          r0 = r10
        else
          r11 = _nt_number
          if r11
            r0 = r11
          else
            r12 = _nt_boolean
            if r12
              r0 = r12
            else
              r13 = _nt_identifier
              if r13
                r0 = r13
              else
                r14 = _nt_string
                if r14
                  r0 = r14
                else
                  i15, s15 = index, []
                  if has_terminal?('-', false, index)
                    r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
                    @index += 1
                  else
                    terminal_parse_failure('-')
                    r16 = nil
                  end
                  s15 << r16
                  if r16
                    r17 = _nt_value
                    s15 << r17
                  end
                  if s15.last
                    r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
                    r15.extend(Value1)
                  else
                    @index = i15
                    r15 = nil
                  end
                  if r15
                    r0 = r15
                  else
                    @index = i0
                    r0 = nil
                  end
                end
              end
            end
          end
        end
      end
    end

    node_cache[:value][start_index] = r0

    r0
  end

  module Function0
  end

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

    i0, s0 = index, []
    s1, i1 = [], index
    loop do
      if has_terminal?('\G[a-zA-Z]', true, index)
        r2 = true
        @index += 1
      else
        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
      if has_terminal?('(', false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('(')
        r3 = nil
      end
      s0 << r3
      if r3
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
        if r4
          r7 = _nt_arguments
          if r7
            r6 = r7
          else
            r6 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r6
          if r6
            r9 = _nt_space
            if r9
              r8 = r9
            else
              r8 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r8
            if r8
              if has_terminal?(')', false, index)
                r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure(')')
                r10 = nil
              end
              s0 << r10
            end
          end
        end
      end
    end
    if s0.last
      r0 = instantiate_node(Function,input, i0...index, s0)
      r0.extend(Function0)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:function][start_index] = r0

    r0
  end

  module Arguments0
    def logical
      elements[3]
    end
  end

  module Arguments1
    def logical
      elements[0]
    end

  end

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

    i0, s0 = index, []
    r1 = _nt_logical
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3, s3 = index, []
        r5 = _nt_space
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s3 << r4
        if r4
          if has_terminal?(',', false, index)
            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(',')
            r6 = nil
          end
          s3 << r6
          if r6
            r8 = _nt_space
            if r8
              r7 = r8
            else
              r7 = instantiate_node(SyntaxNode,input, index...index)
            end
            s3 << r7
            if r7
              r9 = _nt_logical
              s3 << r9
            end
          end
        end
        if s3.last
          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
          r3.extend(Arguments0)
        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(Arguments1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:arguments][start_index] = r0

    r0
  end

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

    i0 = index
    r1 = _nt_float
    if r1
      r0 = r1
    else
      r2 = _nt_integer
      if r2
        r0 = r2
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:number][start_index] = r0

    r0
  end

  module Float0
  end

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

    i0, s0 = index, []
    s1, i1 = [], index
    loop do
      if has_terminal?('\G[0-9]', true, index)
        r2 = true
        @index += 1
      else
        r2 = nil
      end
      if r2
        s1 << r2
      else
        break
      end
    end
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    s0 << r1
    if r1
      if has_terminal?('.', false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('.')
        r3 = nil
      end
      s0 << r3
      if r3
        s4, i4 = [], index
        loop do
          if has_terminal?('\G[0-9]', true, index)
            r5 = true
            @index += 1
          else
            r5 = nil
          end
          if r5
            s4 << r5
          else
            break
          end
        end
        if s4.empty?
          @index = i4
          r4 = nil
        else
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        end
        s0 << r4
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(Float0)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:float][start_index] = r0

    r0
  end

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

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

    node_cache[:integer][start_index] = r0

    r0
  end

  module Identifier0
  end

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

    i0, s0 = index, []
    if has_terminal?('\G[a-zA-Z]', true, index)
      r1 = true
      @index += 1
    else
      r1 = nil
    end
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        if has_terminal?('\G[a-zA-Z0-9]', true, index)
          r3 = true
          @index += 1
        else
          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(Identifier,input, i0...index, s0)
      r0.extend(Identifier0)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:identifier][start_index] = r0

    r0
  end

  module Label0
  end

  module Label1
  end

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

    i0 = index
    i1, s1 = index, []
    s2, i2 = [], index
    loop do
      if has_terminal?('\G[A-Za-z]', true, index)
        r3 = true
        @index += 1
      else
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s1 << r2
    if r2
      if has_terminal?('\G[1-9]', true, index)
        r4 = true
        @index += 1
      else
        r4 = nil
      end
      s1 << r4
      if r4
        s5, i5 = [], index
        loop do
          if has_terminal?('\G[0-9]', true, index)
            r6 = true
            @index += 1
          else
            r6 = nil
          end
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s1 << r5
      end
    end
    if s1.last
      r1 = instantiate_node(Label,input, i1...index, s1)
      r1.extend(Label0)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i7, s7 = index, []
      if has_terminal?('$', false, index)
        r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('$')
        r8 = nil
      end
      s7 << r8
      if r8
        s9, i9 = [], index
        loop do
          if has_terminal?('\G[A-Za-z]', true, index)
            r10 = true
            @index += 1
          else
            r10 = nil
          end
          if r10
            s9 << r10
          else
            break
          end
        end
        if s9.empty?
          @index = i9
          r9 = nil
        else
          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
        end
        s7 << r9
        if r9
          if has_terminal?('$', false, index)
            r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure('$')
            r11 = nil
          end
          s7 << r11
          if r11
            if has_terminal?('\G[1-9]', true, index)
              r12 = true
              @index += 1
            else
              r12 = nil
            end
            s7 << r12
            if r12
              s13, i13 = [], index
              loop do
                if has_terminal?('\G[0-9]', true, index)
                  r14 = true
                  @index += 1
                else
                  r14 = nil
                end
                if r14
                  s13 << r14
                else
                  break
                end
              end
              r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
              s7 << r13
            end
          end
        end
      end
      if s7.last
        r7 = instantiate_node(Label,input, i7...index, s7)
        r7.extend(Label1)
      else
        @index = i7
        r7 = nil
      end
      if r7
        r0 = r7
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:label][start_index] = r0

    r0
  end

  module String0
  end

  module String1
  end

  module String2
  end

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

    i0 = index
    i1, s1 = index, []
    if has_terminal?('"', false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('"')
      r2 = nil
    end
    s1 << r2
    if r2
      s3, i3 = [], index
      loop do
        i4 = index
        if has_terminal?('\"', false, index)
          r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
          @index += 2
        else
          terminal_parse_failure('\"')
          r5 = nil
        end
        if r5
          r4 = r5
        else
          i6, s6 = index, []
          i7 = index
          if has_terminal?('"', false, index)
            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure('"')
            r8 = nil
          end
          if r8
            r7 = nil
          else
            @index = i7
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s6 << r7
          if r7
            if index < input_length
              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure("any character")
              r9 = nil
            end
            s6 << r9
          end
          if s6.last
            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
            r6.extend(String0)
          else
            @index = i6
            r6 = nil
          end
          if r6
            r4 = r6
          else
            @index = i4
            r4 = nil
          end
        end
        if r4
          s3 << r4
        else
          break
        end
      end
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      s1 << r3
      if r3
        if has_terminal?('"', false, index)
          r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('"')
          r10 = nil
        end
        s1 << r10
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(String1)
    else
      @index = i1
      r1 = nil
    end
    if r1
      r0 = r1
    else
      i11, s11 = index, []
      if has_terminal?("'", false, index)
        r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("'")
        r12 = nil
      end
      s11 << r12
      if r12
        s13, i13 = [], index
        loop do
          if has_terminal?('\G[^\']', true, index)
            r14 = true
            @index += 1
          else
            r14 = nil
          end
          if r14
            s13 << r14
          else
            break
          end
        end
        r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
        s11 << r13
        if r13
          if has_terminal?("'", false, index)
            r15 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure("'")
            r15 = nil
          end
          s11 << r15
        end
      end
      if s11.last
        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
        r11.extend(String2)
      else
        @index = i11
        r11 = nil
      end
      if r11
        r0 = r11
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:string][start_index] = r0

    r0
  end

  module Range0
    def label1
      elements[0]
    end

    def label2
      elements[2]
    end
  end

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

    i0, s0 = index, []
    r1 = _nt_label
    s0 << r1
    if r1
      if has_terminal?(':', false, index)
        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(':')
        r2 = nil
      end
      s0 << r2
      if r2
        r3 = _nt_label
        s0 << r3
      end
    end
    if s0.last
      r0 = instantiate_node(Range,input, i0...index, s0)
      r0.extend(Range0)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:range][start_index] = r0

    r0
  end

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

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

    node_cache[:space][start_index] = r0

    r0
  end

end

class SorobanParser < Treetop::Runtime::CompiledParser
  include Soroban
end