edn-abnf 0.5.1 → 0.5.3

data/lib/parser/edngrammar.rb

@@ -1696,14 +1696,6 @@ module EDNGRAMMAR
     def ast                       # XXX ignoring h and b64
       data = sqstr.ast.force_encoding(Encoding::UTF_8) # XXX undo .b
       app = app_prefix.text_value
-      # Find a better place to put a default initialization
-      EDNGRAMMAR.const_set(:APPS, Hash.new { |h, k|
-                             h[k] = begin ::CBOR_DIAG.const_get("App_#{k.downcase}")
-  
-                                    rescue NameError
-                                      raise ArgumentError, "cbor-diagnostic: Unknown application-oriented extension '#{k}'", caller
-                                    end
-                           }) unless ::EDNGRAMMAR.const_defined?(:APPS)
       ::EDNGRAMMAR::APPS[app].decode(app, data)
     end
   end
@@ -1756,13 +1748,6 @@ module EDNGRAMMAR
       args = seq.ast
       app = app_prefix.text_value
       # Find a better place to put a default initialization
-      EDNGRAMMAR.const_set(:APPS, Hash.new { |h, k|
-                             h[k] = begin ::CBOR_DIAG.const_get("App_#{k.downcase}")
-  
-                                    rescue NameError
-                                      raise ArgumentError, "cbor-diagnostic: Unknown application-oriented extension '#{k}'", caller
-                                    end
-                           }) unless ::EDNGRAMMAR.const_defined?(:APPS)
       ::EDNGRAMMAR::APPS[app].decode(app, args)
     end
   end
@@ -1892,28 +1877,34 @@ module EDNGRAMMAR
     end
 
     i0 = index
-    r1 = _nt_app_string
+    r1 = _nt_sq_app_string_h
     if r1
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
     else
-      r2 = _nt_sqstr
+      r2 = _nt_app_string
       if r2
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
       else
-        r3 = _nt_app_sequence
+        r3 = _nt_sqstr
         if r3
           r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
           r0 = r3
         else
-          r4 = _nt_embedded
+          r4 = _nt_app_sequence
           if r4
             r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
             r0 = r4
           else
-            @index = i0
-            r0 = nil
+            r5 = _nt_embedded
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              @index = i0
+              r0 = nil
+            end
           end
         end
       end
@@ -2595,24 +2586,18 @@ module EDNGRAMMAR
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
       else
-        if has_terminal?(@regexps[gr = '\A[0-퟿]'] ||= Regexp.new(gr), :regexp, index)
+        if has_terminal?(@regexps[gr = '\A[0-]'] ||= Regexp.new(gr), :regexp, index)
           r3 = true
           @index += 1
         else
-          terminal_parse_failure('[0-퟿]')
+          terminal_parse_failure('[0-]')
           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
+          r4 = _nt_NONASCII
           if r4
             r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
             r0 = r4
@@ -2663,24 +2648,18 @@ module EDNGRAMMAR
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
       else
-        if has_terminal?(@regexps[gr = '\A[\\ -퟿]'] ||= Regexp.new(gr), :regexp, index)
+        if has_terminal?(@regexps[gr = '\A[\\ -]'] ||= Regexp.new(gr), :regexp, index)
           r3 = true
           @index += 1
         else
-          terminal_parse_failure('[\\ -퟿]')
+          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
+          r4 = _nt_NONASCII
           if r4
             r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
             r0 = r4
@@ -3367,23 +3346,13 @@ module EDNGRAMMAR
   end
 
   module DoubleQuoted2
-    def DQUOTE
+    def escapable_d
       elements[1]
     end
   end
 
   module DoubleQuoted3
-    def ast; elements[1].text_value end
-  end
-
-  module DoubleQuoted4
-    def escapable
-      elements[1]
-    end
-  end
-
-  module DoubleQuoted5
-    def ast; escapable.ast end
+    def ast; escapable_d.ast end
   end
 
   def _nt_double_quoted
@@ -3422,7 +3391,7 @@ module EDNGRAMMAR
         end
         s3 << r4
         if r4
-          r5 = _nt_DQUOTE
+          r5 = _nt_escapable_d
           s3 << r5
         end
         if s3.last
@@ -3437,34 +3406,8 @@ module EDNGRAMMAR
           r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
           r0 = r3
         else
-          i6, s6 = index, []
-          if (match_len = has_terminal?("\\", false, index))
-            r7 = true
-            @index += match_len
-          else
-            terminal_parse_failure('"\\\\"')
-            r7 = nil
-          end
-          s6 << r7
-          if r7
-            r8 = _nt_escapable
-            s6 << r8
-          end
-          if s6.last
-            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-            r6.extend(DoubleQuoted4)
-            r6.extend(DoubleQuoted5)
-          else
-            @index = i6
-            r6 = nil
-          end
-          if r6
-            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
-            r0 = r6
-          else
-            @index = i0
-            r0 = nil
-          end
+          @index = i0
+          r0 = nil
         end
       end
     end
@@ -3483,23 +3426,13 @@ module EDNGRAMMAR
   end
 
   module SingleQuoted2
-    def SQUOTE
+    def escapable_s
       elements[1]
     end
   end
 
   module SingleQuoted3
-    def ast; elements[1].text_value end
-  end
-
-  module SingleQuoted4
-    def escapable
-      elements[1]
-    end
-  end
-
-  module SingleQuoted5
-    def ast; escapable.ast end
+    def ast; escapable_s.ast end
   end
 
   def _nt_single_quoted
@@ -3538,7 +3471,7 @@ module EDNGRAMMAR
         end
         s3 << r4
         if r4
-          r5 = _nt_SQUOTE
+          r5 = _nt_escapable_s
           s3 << r5
         end
         if s3.last
@@ -3553,34 +3486,8 @@ module EDNGRAMMAR
           r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
           r0 = r3
         else
-          i6, s6 = index, []
-          if (match_len = has_terminal?("\\", false, index))
-            r7 = true
-            @index += match_len
-          else
-            terminal_parse_failure('"\\\\"')
-            r7 = nil
-          end
-          s6 << r7
-          if r7
-            r8 = _nt_escapable
-            s6 << r8
-          end
-          if s6.last
-            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-            r6.extend(SingleQuoted4)
-            r6.extend(SingleQuoted5)
-          else
-            @index = i6
-            r6 = nil
-          end
-          if r6
-            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
-            r0 = r6
-          else
-            @index = i0
-            r0 = nil
-          end
+          @index = i0
+          r0 = nil
         end
       end
     end
@@ -3590,50 +3497,36 @@ module EDNGRAMMAR
     r0
   end
 
-  module Escapable0
+  module Escapable10
     def ast; "\b" end
   end
 
-  module Escapable1
+  module Escapable11
     def ast; "\f" end
   end
 
-  module Escapable2
+  module Escapable12
     def ast; "\n" end
   end
 
-  module Escapable3
+  module Escapable13
     def ast; "\r" end
   end
 
-  module Escapable4
+  module Escapable14
     def ast; "\t" end
   end
 
-  module Escapable5
-    def ast; text_value end
-  end
-
-  module Escapable6
+  module Escapable15
     def ast; text_value end
   end
 
-  module Escapable7
-    def hexchar
-      elements[1]
-    end
-  end
-
-  module Escapable8
-    def ast; hexchar.ast end
-  end
-
-  def _nt_escapable
+  def _nt_escapable1
     start_index = index
-    if node_cache[:escapable].has_key?(index)
-      cached = node_cache[:escapable][index]
+    if node_cache[:escapable1].has_key?(index)
+      cached = node_cache[:escapable1][index]
       if cached
-        node_cache[:escapable][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:escapable1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -3642,7 +3535,7 @@ module EDNGRAMMAR
     i0 = index
     if (match_len = has_terminal?("b", false, index))
       r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-      r1.extend(Escapable0)
+      r1.extend(Escapable10)
       @index += match_len
     else
       terminal_parse_failure('"b"')
@@ -3654,7 +3547,7 @@ module EDNGRAMMAR
     else
       if (match_len = has_terminal?("f", false, index))
         r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-        r2.extend(Escapable1)
+        r2.extend(Escapable11)
         @index += match_len
       else
         terminal_parse_failure('"f"')
@@ -3666,7 +3559,7 @@ module EDNGRAMMAR
       else
         if (match_len = has_terminal?("n", false, index))
           r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-          r3.extend(Escapable2)
+          r3.extend(Escapable12)
           @index += match_len
         else
           terminal_parse_failure('"n"')
@@ -3678,7 +3571,7 @@ module EDNGRAMMAR
         else
           if (match_len = has_terminal?("r", false, index))
             r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-            r4.extend(Escapable3)
+            r4.extend(Escapable13)
             @index += match_len
           else
             terminal_parse_failure('"r"')
@@ -3690,7 +3583,7 @@ module EDNGRAMMAR
           else
             if (match_len = has_terminal?("t", false, index))
               r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-              r5.extend(Escapable4)
+              r5.extend(Escapable14)
               @index += match_len
             else
               terminal_parse_failure('"t"')
@@ -3700,59 +3593,20 @@ module EDNGRAMMAR
               r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
               r0 = r5
             else
-              if (match_len = has_terminal?("/", false, index))
+              if (match_len = has_terminal?("\\", false, index))
                 r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                r6.extend(Escapable5)
+                r6.extend(Escapable15)
                 @index += match_len
               else
-                terminal_parse_failure('"/"')
+                terminal_parse_failure('"\\\\"')
                 r6 = nil
               end
               if r6
                 r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
                 r0 = r6
               else
-                if (match_len = has_terminal?("\\", false, index))
-                  r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                  r7.extend(Escapable6)
-                  @index += match_len
-                else
-                  terminal_parse_failure('"\\\\"')
-                  r7 = nil
-                end
-                if r7
-                  r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
-                  r0 = r7
-                else
-                  i8, s8 = index, []
-                  if (match_len = has_terminal?("u", false, index))
-                    r9 = true
-                    @index += match_len
-                  else
-                    terminal_parse_failure('"u"')
-                    r9 = nil
-                  end
-                  s8 << r9
-                  if r9
-                    r10 = _nt_hexchar
-                    s8 << r10
-                  end
-                  if s8.last
-                    r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
-                    r8.extend(Escapable7)
-                    r8.extend(Escapable8)
-                  else
-                    @index = i8
-                    r8 = nil
-                  end
-                  if r8
-                    r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
-                    r0 = r8
-                  else
-                    @index = i0
-                    r0 = nil
-                  end
-                end
+                @index = i0
+                r0 = nil
               end
             end
           end
@@ -3760,39 +3614,188 @@ module EDNGRAMMAR
       end
     end
 
-    node_cache[:escapable][start_index] = r0
+    node_cache[:escapable1][start_index] = r0
 
     r0
   end
 
-  module Hexchar0
+  module EscapableD0
+    def ast; text_value end
   end
 
-  module Hexchar1
+  module EscapableD1
+    def ast; text_value end
   end
 
-  module Hexchar2
-    def ast; elements[1].hex_value.chr(Encoding::UTF_8) end
+  module EscapableD2
+    def hexchar
+      elements[1]
+    end
   end
 
-  module Hexchar3
-    def ast; hex_value.chr(Encoding::UTF_8) end
+  module EscapableD3
+    def ast; hexchar.ast end
   end
 
-  module Hexchar4
-    def high_surrogate
-      elements[0]
+  def _nt_escapable_d
+    start_index = index
+    if node_cache[:escapable_d].has_key?(index)
+      cached = node_cache[:escapable_d][index]
+      if cached
+        node_cache[:escapable_d][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
     end
 
-    def low_surrogate
-      elements[3]
+    i0 = index
+    r1 = _nt_escapable1
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_DQUOTE
+      r2.extend(EscapableD0)
+      r2.extend(EscapableD0)
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if (match_len = has_terminal?("/", false, index))
+          r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          r3.extend(EscapableD1)
+          @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
+          i4, s4 = index, []
+          if (match_len = has_terminal?("u", false, index))
+            r5 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"u"')
+            r5 = nil
+          end
+          s4 << r5
+          if r5
+            r6 = _nt_hexchar
+            s4 << r6
+          end
+          if s4.last
+            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            r4.extend(EscapableD2)
+            r4.extend(EscapableD3)
+          else
+            @index = i4
+            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[:escapable_d][start_index] = r0
+
+    r0
   end
 
-  module Hexchar5
-    def ast
-      ((high_surrogate.ast << 10) + low_surrogate.ast + 0x10000).chr(Encoding::UTF_8)
+  module EscapableS0
+    def ast; text_value end
+  end
+
+  module EscapableS1
+    def hexchar_s
+      elements[1]
+    end
+  end
+
+  module EscapableS2
+    def ast; hexchar_s.ast end
+  end
+
+  def _nt_escapable_s
+    start_index = index
+    if node_cache[:escapable_s].has_key?(index)
+      cached = node_cache[:escapable_s][index]
+      if cached
+        node_cache[:escapable_s][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_escapable1
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_SQUOTE
+      r2.extend(EscapableS0)
+      r2.extend(EscapableS0)
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        i3, s3 = index, []
+        if (match_len = has_terminal?("u", false, index))
+          r4 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"u"')
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          r5 = _nt_hexchar_s
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(EscapableS1)
+          r3.extend(EscapableS2)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
     end
+
+    node_cache[:escapable_s][start_index] = r0
+
+    r0
+  end
+
+  module Hexchar0
+  end
+
+  module Hexchar1
+  end
+
+  module Hexchar2
+    def ast; elements[1].hex_value.chr(Encoding::UTF_8) end
+  end
+
+  module Hexchar3
+    def ast; hex_value.chr(Encoding::UTF_8) end
   end
 
   def _nt_hexchar
@@ -3901,41 +3904,7 @@ module EDNGRAMMAR
         r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
         r0 = r11
       else
-        i12, s12 = index, []
-        r13 = _nt_high_surrogate
-        s12 << r13
-        if r13
-          if (match_len = has_terminal?("\\", false, index))
-            r14 = true
-            @index += match_len
-          else
-            terminal_parse_failure('"\\\\"')
-            r14 = nil
-          end
-          s12 << r14
-          if r14
-            if (match_len = has_terminal?("u", false, index))
-              r15 = true
-              @index += match_len
-            else
-              terminal_parse_failure('"u"')
-              r15 = nil
-            end
-            s12 << r15
-            if r15
-              r16 = _nt_low_surrogate
-              s12 << r16
-            end
-          end
-        end
-        if s12.last
-          r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
-          r12.extend(Hexchar4)
-          r12.extend(Hexchar5)
-        else
-          @index = i12
-          r12 = nil
-        end
+        r12 = _nt_two_surrogate
         if r12
           r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
           r0 = r12
@@ -4137,6 +4106,74 @@ module EDNGRAMMAR
     r0
   end
 
+  module TwoSurrogate0
+    def high_surrogate
+      elements[0]
+    end
+
+    def low_surrogate
+      elements[3]
+    end
+  end
+
+  module TwoSurrogate1
+    def ast
+      ((high_surrogate.ast << 10) + low_surrogate.ast + 0x10000).chr(Encoding::UTF_8)
+    end
+  end
+
+  def _nt_two_surrogate
+    start_index = index
+    if node_cache[:two_surrogate].has_key?(index)
+      cached = node_cache[:two_surrogate][index]
+      if cached
+        node_cache[:two_surrogate][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_high_surrogate
+    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
+        if (match_len = has_terminal?("u", false, index))
+          r3 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"u"')
+          r3 = nil
+        end
+        s0 << r3
+        if r3
+          r4 = _nt_low_surrogate
+          s0 << r4
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TwoSurrogate0)
+      r0.extend(TwoSurrogate1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:two_surrogate][start_index] = r0
+
+    r0
+  end
+
   module HighSurrogate0
   end
 
@@ -4521,339 +4558,3032 @@ module EDNGRAMMAR
     r0
   end
 
-  def _nt_unescaped
+  module HexcharS0
+  end
+
+  module HexcharS1
+  end
+
+  module HexcharS2
+    def ast; elements[1].hex_value.chr(Encoding::UTF_8) end
+  end
+
+  module HexcharS3
+    def ast; hex_value.chr(Encoding::UTF_8) end
+  end
+
+  def _nt_hexchar_s
     start_index = index
-    if node_cache[:unescaped].has_key?(index)
-      cached = node_cache[:unescaped][index]
+    if node_cache[:hexchar_s].has_key?(index)
+      cached = node_cache[:hexchar_s][index]
       if cached
-        node_cache[:unescaped][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:hexchar_s][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
+    i1, s1 = index, []
+    if (match_len = has_terminal?("{", false, index))
+      r2 = true
       @index += match_len
     else
-      terminal_parse_failure('"\\n"')
-      r1 = nil
+      terminal_parse_failure('"{"')
+      r2 = nil
     end
-    if r1
-      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
-      r0 = r1
-    else
-      if (match_len = has_terminal?("\r", false, index))
-        r2 = true
-        @index += match_len
+    s1 << r2
+    if r2
+      i3 = index
+      i4, s4 = index, []
+      s5, i5 = [], index
+      loop do
+        if (match_len = has_terminal?("0", false, index))
+          r6 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"0"')
+          r6 = nil
+        end
+        if r6
+          s5 << r6
+        else
+          break
+        end
+      end
+      if s5.empty?
+        @index = i5
+        r5 = nil
       else
-        terminal_parse_failure('"\\r"')
-        r2 = nil
+        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
       end
-      if r2
-        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-        r0 = r2
+      s4 << r5
+      if r5
+        r8 = _nt_hexscalar_s
+        if r8
+          r7 = r8
+        else
+          r7 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s4 << r7
+      end
+      if s4.last
+        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        r4.extend(HexcharS0)
       else
-        if has_terminal?(@regexps[gr = '\A[\\ -!]'] ||= Regexp.new(gr), :regexp, index)
-          r3 = true
-          @index += 1
+        @index = i4
+        r4 = nil
+      end
+      if r4
+        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+        r3 = r4
+      else
+        r9 = _nt_hexscalar_s
+        if r9
+          r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+          r3 = r9
         else
-          terminal_parse_failure('[\\ -!]')
+          @index = i3
           r3 = nil
         end
-        if r3
-          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-          r0 = r3
+      end
+      s1 << r3
+      if r3
+        if (match_len = has_terminal?("}", false, index))
+          r10 = true
+          @index += match_len
         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
-            if has_terminal?(@regexps[gr = '\A[\\(-\\[]'] ||= Regexp.new(gr), :regexp, index)
-              r5 = true
-              @index += 1
-            else
-              terminal_parse_failure('[\\(-\\[]')
-              r5 = nil
-            end
-            if r5
-              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
-              r0 = r5
-            else
-              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
-                r0 = 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
-                  r0 = r7
-                else
-                  @index = i0
-                  r0 = nil
-                end
-              end
-            end
-          end
+          terminal_parse_failure('"}"')
+          r10 = nil
+        end
+        s1 << r10
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(HexcharS1)
+      r1.extend(HexcharS2)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r11 = _nt_non_surrogate_s
+      r11.extend(HexcharS3)
+      r11.extend(HexcharS3)
+      if r11
+        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+        r0 = r11
+      else
+        r12 = _nt_two_surrogate
+        if r12
+          r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+          r0 = r12
+        else
+          @index = i0
+          r0 = nil
         end
       end
     end
 
-    node_cache[:unescaped][start_index] = r0
+    node_cache[:hexchar_s][start_index] = r0
 
     r0
   end
 
-  def _nt_DQUOTE
+  module NonSurrogateS0
+    def HEXDIG
+      elements[2]
+    end
+  end
+
+  module NonSurrogateS1
+    def HEXDIG1
+      elements[1]
+    end
+
+  end
+
+  def _nt_non_surrogate_s
     start_index = index
-    if node_cache[:DQUOTE].has_key?(index)
-      cached = node_cache[:DQUOTE][index]
+    if node_cache[:non_surrogate_s].has_key?(index)
+      cached = node_cache[:non_surrogate_s][index]
       if cached
-        node_cache[:DQUOTE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:non_surrogate_s][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))
+    i0 = index
+    if (match_len = has_terminal?("007f", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"007F"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i2, s2 = index, []
+      if (match_len = has_terminal?("00", false, index))
+        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"00"')
+        r3 = nil
+      end
+      s2 << r3
+      if r3
+        i4 = index
+        if (match_len = has_terminal?("0", false, index))
+          r5 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"0"')
+          r5 = nil
+        end
+        if r5
+          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+          r4 = r5
+        else
+          if (match_len = has_terminal?("1", false, index))
+            r6 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"1"')
+            r6 = nil
+          end
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r4 = r6
+          else
+            if (match_len = has_terminal?("8", false, index))
+              r7 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"8"')
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r4 = r7
+            else
+              if (match_len = has_terminal?("9", false, index))
+                r8 = true
+                @index += match_len
+              else
+                terminal_parse_failure('"9"')
+                r8 = nil
+              end
+              if r8
+                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                r4 = r8
+              else
+                r9 = _nt_HEXDIGA
+                if r9
+                  r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+                  r4 = r9
+                else
+                  @index = i4
+                  r4 = nil
+                end
+              end
+            end
+          end
+        end
+        s2 << r4
+        if r4
+          r10 = _nt_HEXDIG
+          s2 << r10
+        end
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(NonSurrogateS0)
+      else
+        @index = i2
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        i11, s11 = index, []
+        if (match_len = has_terminal?("0", false, index))
+          r12 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"0"')
+          r12 = nil
+        end
+        s11 << r12
+        if r12
+          r13 = _nt_HEXDIG1
+          s11 << r13
+          if r13
+            s14, i14 = [], index
+            loop do
+              r15 = _nt_HEXDIG
+              if r15
+                s14 << r15
+              else
+                break
+              end
+              if s14.size == 2
+                break
+              end
+            end
+            if s14.size < 2
+              @index = i14
+              r14 = nil
+            else
+              if s14.size < 2
+                @terminal_failures.pop
+              end
+              r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
+            end
+            s11 << r14
+          end
+        end
+        if s11.last
+          r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+          r11.extend(NonSurrogateS1)
+        else
+          @index = i11
+          r11 = nil
+        end
+        if r11
+          r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+          r0 = r11
+        else
+          r16 = _nt_non_surrogate_1
+          if r16
+            r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
+            r0 = r16
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:non_surrogate_s][start_index] = r0
+
+    r0
+  end
+
+  module NonSurrogate10
+  end
+
+  module NonSurrogate11
+    def ODIGIT
+      elements[1]
+    end
+
+  end
+
+  def _nt_non_surrogate_1
+    start_index = index
+    if node_cache[:non_surrogate_1].has_key?(index)
+      cached = node_cache[:non_surrogate_1][index]
+      if cached
+        node_cache[:non_surrogate_1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    i2 = index
+    r3 = _nt_DIGIT1
+    if r3
+      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+      r2 = r3
+    else
+      if (match_len = has_terminal?("a", :insens, index))
+        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"A"')
+        r4 = nil
+      end
+      if r4
+        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+        r2 = r4
+      else
+        if (match_len = has_terminal?("b", :insens, index))
+          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"B"')
+          r5 = nil
+        end
+        if r5
+          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+          r2 = r5
+        else
+          if (match_len = has_terminal?("c", :insens, index))
+            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"C"')
+            r6 = nil
+          end
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r2 = r6
+          else
+            if (match_len = has_terminal?("e", :insens, index))
+              r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+              @index += match_len
+            else
+              terminal_parse_failure('"E"')
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r2 = r7
+            else
+              if (match_len = has_terminal?("f", :insens, index))
+                r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                @index += match_len
+              else
+                terminal_parse_failure('"F"')
+                r8 = nil
+              end
+              if r8
+                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                r2 = r8
+              else
+                @index = i2
+                r2 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+    s1 << r2
+    if r2
+      s9, i9 = [], index
+      loop do
+        r10 = _nt_HEXDIG
+        if r10
+          s9 << r10
+        else
+          break
+        end
+        if s9.size == 3
+          break
+        end
+      end
+      if s9.size < 3
+        @index = i9
+        r9 = nil
+      else
+        if s9.size < 3
+          @terminal_failures.pop
+        end
+        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+      end
+      s1 << r9
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(NonSurrogate10)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i11, s11 = index, []
+      if (match_len = has_terminal?("d", :insens, index))
+        r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"D"')
+        r12 = nil
+      end
+      s11 << r12
+      if r12
+        r13 = _nt_ODIGIT
+        s11 << r13
+        if r13
+          s14, i14 = [], index
+          loop do
+            r15 = _nt_HEXDIG
+            if r15
+              s14 << r15
+            else
+              break
+            end
+            if s14.size == 2
+              break
+            end
+          end
+          if s14.size < 2
+            @index = i14
+            r14 = nil
+          else
+            if s14.size < 2
+              @terminal_failures.pop
+            end
+            r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
+          end
+          s11 << r14
+        end
+      end
+      if s11.last
+        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+        r11.extend(NonSurrogate11)
+      else
+        @index = i11
+        r11 = nil
+      end
+      if r11
+        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+        r0 = r11
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:non_surrogate_1][start_index] = r0
+
+    r0
+  end
+
+  module HexscalarS0
+  end
+
+  module HexscalarS1
+    def HEXDIG1
+      elements[0]
+    end
+
+  end
+
+  module HexscalarS2
+    def HEXDIG1
+      elements[0]
+    end
+
+  end
+
+  module HexscalarS3
+    def HEXDIG
+      elements[1]
+    end
+  end
+
+  def _nt_hexscalar_s
+    start_index = index
+    if node_cache[:hexscalar_s].has_key?(index)
+      cached = node_cache[:hexscalar_s][index]
+      if cached
+        node_cache[:hexscalar_s][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if (match_len = has_terminal?("10", false, index))
+      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"10"')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      s3, i3 = [], index
+      loop do
+        r4 = _nt_HEXDIG
+        if r4
+          s3 << r4
+        else
+          break
+        end
+        if s3.size == 4
+          break
+        end
+      end
+      if s3.size < 4
+        @index = i3
+        r3 = nil
+      else
+        if s3.size < 4
+          @terminal_failures.pop
+        end
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      end
+      s1 << r3
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(HexscalarS0)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i5, s5 = index, []
+      r6 = _nt_HEXDIG1
+      s5 << r6
+      if r6
+        s7, i7 = [], index
+        loop do
+          r8 = _nt_HEXDIG
+          if r8
+            s7 << r8
+          else
+            break
+          end
+          if s7.size == 4
+            break
+          end
+        end
+        if s7.size < 4
+          @index = i7
+          r7 = nil
+        else
+          if s7.size < 4
+            @terminal_failures.pop
+          end
+          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(HexscalarS1)
+      else
+        @index = i5
+        r5 = nil
+      end
+      if r5
+        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+        r0 = r5
+      else
+        r9 = _nt_non_surrogate_1
+        if r9
+          r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+          r0 = r9
+        else
+          i10, s10 = index, []
+          r11 = _nt_HEXDIG1
+          s10 << r11
+          if r11
+            s12, i12 = [], index
+            loop do
+              r13 = _nt_HEXDIG
+              if r13
+                s12 << r13
+              else
+                break
+              end
+              if s12.size == 2
+                break
+              end
+            end
+            if s12.size < 2
+              @index = i12
+              r12 = nil
+            else
+              if s12.size < 2
+                @terminal_failures.pop
+              end
+              r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+            end
+            s10 << r12
+          end
+          if s10.last
+            r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+            r10.extend(HexscalarS2)
+          else
+            @index = i10
+            r10 = nil
+          end
+          if r10
+            r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
+            r0 = r10
+          else
+            i14, s14 = index, []
+            i15 = index
+            if (match_len = has_terminal?("1", false, index))
+              r16 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"1"')
+              r16 = nil
+            end
+            if r16
+              r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
+              r15 = r16
+            else
+              if (match_len = has_terminal?("8", false, index))
+                r17 = true
+                @index += match_len
+              else
+                terminal_parse_failure('"8"')
+                r17 = nil
+              end
+              if r17
+                r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
+                r15 = r17
+              else
+                if (match_len = has_terminal?("9", false, index))
+                  r18 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"9"')
+                  r18 = nil
+                end
+                if r18
+                  r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
+                  r15 = r18
+                else
+                  r19 = _nt_HEXDIGA
+                  if r19
+                    r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
+                    r15 = r19
+                  else
+                    @index = i15
+                    r15 = nil
+                  end
+                end
+              end
+            end
+            s14 << r15
+            if r15
+              r20 = _nt_HEXDIG
+              s14 << r20
+            end
+            if s14.last
+              r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
+              r14.extend(HexscalarS3)
+            else
+              @index = i14
+              r14 = nil
+            end
+            if r14
+              r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
+              r0 = r14
+            else
+              if (match_len = has_terminal?("7f", :insens, index))
+                r21 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                @index += match_len
+              else
+                terminal_parse_failure('"7F"')
+                r21 = nil
+              end
+              if r21
+                r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
+                r0 = r21
+              else
+                r22 = _nt_HEXDIG1
+                if r22
+                  r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
+                  r0 = r22
+                else
+                  @index = i0
+                  r0 = nil
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:hexscalar_s][start_index] = r0
+
+    r0
+  end
+
+  def _nt_unescaped
+    start_index = index
+    if node_cache[:unescaped].has_key?(index)
+      cached = node_cache[:unescaped][index]
+      if cached
+        node_cache[:unescaped][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", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"\\r"')
+        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
+            if has_terminal?(@regexps[gr = '\A[\\(-\\[]'] ||= Regexp.new(gr), :regexp, index)
+              r5 = true
+              @index += 1
+            else
+              terminal_parse_failure('[\\(-\\[]')
+              r5 = nil
+            end
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              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
+                r0 = r6
+              else
+                r7 = _nt_NONASCII
+                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[:unescaped][start_index] = r0
+
+    r0
+  end
+
+  def _nt_DQUOTE
+    start_index = index
+    if node_cache[:DQUOTE].has_key?(index)
+      cached = node_cache[:DQUOTE][index]
+      if cached
+        node_cache[:DQUOTE][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[:DQUOTE][start_index] = r0
+    node_cache[:DQUOTE][start_index] = r0
+
+    r0
+  end
+
+  def _nt_SQUOTE
+    start_index = index
+    if node_cache[:SQUOTE].has_key?(index)
+      cached = node_cache[:SQUOTE][index]
+      if cached
+        node_cache[:SQUOTE][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[:SQUOTE][start_index] = r0
+
+    r0
+  end
+
+  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
+
+  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
+
+  def _nt_ODIGIT
+    start_index = index
+    if node_cache[:ODIGIT].has_key?(index)
+      cached = node_cache[:ODIGIT][index]
+      if cached
+        node_cache[:ODIGIT][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-7]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[0-7]')
+      r0 = nil
+    end
+
+    node_cache[:ODIGIT][start_index] = r0
+
+    r0
+  end
+
+  def _nt_BDIGIT
+    start_index = index
+    if node_cache[:BDIGIT].has_key?(index)
+      cached = node_cache[:BDIGIT][index]
+      if cached
+        node_cache[:BDIGIT][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[:BDIGIT][start_index] = r0
+
+    r0
+  end
+
+  def _nt_HEXDIGA
+    start_index = index
+    if node_cache[:HEXDIGA].has_key?(index)
+      cached = node_cache[:HEXDIGA][index]
+      if cached
+        node_cache[:HEXDIGA][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if (match_len = has_terminal?("a", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"A"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("b", :insens, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"B"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if (match_len = has_terminal?("c", :insens, index))
+          r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"C"')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          if (match_len = has_terminal?("d", :insens, index))
+            r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"D"')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            if (match_len = has_terminal?("e", :insens, index))
+              r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+              @index += match_len
+            else
+              terminal_parse_failure('"E"')
+              r5 = nil
+            end
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              if (match_len = has_terminal?("f", :insens, index))
+                r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                @index += match_len
+              else
+                terminal_parse_failure('"F"')
+                r6 = nil
+              end
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r0 = r6
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:HEXDIGA][start_index] = r0
+
+    r0
+  end
+
+  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
+      r2 = _nt_HEXDIGA
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:HEXDIG][start_index] = r0
+
+    r0
+  end
+
+  def _nt_HEXDIG1
+    start_index = index
+    if node_cache[:HEXDIG1].has_key?(index)
+      cached = node_cache[:HEXDIG1][index]
+      if cached
+        node_cache[:HEXDIG1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_DIGIT1
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_HEXDIGA
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:HEXDIG1][start_index] = r0
+
+    r0
+  end
+
+  def _nt_lcalpha
+    start_index = index
+    if node_cache[:lcalpha].has_key?(index)
+      cached = node_cache[:lcalpha][index]
+      if cached
+        node_cache[:lcalpha][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[a-z]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[a-z]')
+      r0 = nil
+    end
+
+    node_cache[:lcalpha][start_index] = r0
+
+    r0
+  end
+
+  def _nt_lcalnum
+    start_index = index
+    if node_cache[:lcalnum].has_key?(index)
+      cached = node_cache[:lcalnum][index]
+      if cached
+        node_cache[:lcalnum][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_lcalpha
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_DIGIT
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:lcalnum][start_index] = r0
+
+    r0
+  end
+
+  def _nt_ucalpha
+    start_index = index
+    if node_cache[:ucalpha].has_key?(index)
+      cached = node_cache[:ucalpha][index]
+      if cached
+        node_cache[:ucalpha][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[A-Z]')
+      r0 = nil
+    end
+
+    node_cache[:ucalpha][start_index] = r0
+
+    r0
+  end
+
+  def _nt_ucalnum
+    start_index = index
+    if node_cache[:ucalnum].has_key?(index)
+      cached = node_cache[:ucalnum][index]
+      if cached
+        node_cache[:ucalnum][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_ucalpha
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_DIGIT
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:ucalnum][start_index] = r0
+
+    r0
+  end
+
+  def _nt_wordchar
+    start_index = index
+    if node_cache[:wordchar].has_key?(index)
+      cached = node_cache[:wordchar][index]
+      if cached
+        node_cache[:wordchar][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if (match_len = has_terminal?("_", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"_"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_lcalnum
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        r3 = _nt_ucalpha
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:wordchar][start_index] = r0
+
+    r0
+  end
+
+  def _nt_NONASCII
+    start_index = index
+    if node_cache[:NONASCII].has_key?(index)
+      cached = node_cache[:NONASCII][index]
+      if cached
+        node_cache[:NONASCII][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[:NONASCII][start_index] = r0
+
+    r0
+  end
+
+  module IHT0
+  end
+
+  module IHT1
+  end
+
+  def _nt_i_HT
+    start_index = index
+    if node_cache[:i_HT].has_key?(index)
+      cached = node_cache[:i_HT][index]
+      if cached
+        node_cache[:i_HT][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?("\\t", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"\\\\t"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i2, s2 = index, []
+      if (match_len = has_terminal?("\\u", false, index))
+        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"\\\\u"')
+        r3 = nil
+      end
+      s2 << r3
+      if r3
+        i4 = index
+        if (match_len = has_terminal?("0009", false, index))
+          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"0009"')
+          r5 = nil
+        end
+        if r5
+          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+          r4 = r5
+        else
+          i6, s6 = index, []
+          if (match_len = has_terminal?("{", false, index))
+            r7 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"{"')
+            r7 = nil
+          end
+          s6 << r7
+          if r7
+            s8, i8 = [], index
+            loop do
+              if (match_len = has_terminal?("0", false, index))
+                r9 = true
+                @index += match_len
+              else
+                terminal_parse_failure('"0"')
+                r9 = nil
+              end
+              if r9
+                s8 << r9
+              else
+                break
+              end
+            end
+            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+            s6 << r8
+            if r8
+              if (match_len = has_terminal?("9}", false, index))
+                r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                @index += match_len
+              else
+                terminal_parse_failure('"9}"')
+                r10 = nil
+              end
+              s6 << r10
+            end
+          end
+          if s6.last
+            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+            r6.extend(IHT0)
+          else
+            @index = i6
+            r6 = nil
+          end
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r4 = r6
+          else
+            @index = i4
+            r4 = nil
+          end
+        end
+        s2 << r4
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(IHT1)
+      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[:i_HT][start_index] = r0
+
+    r0
+  end
+
+  module ILF0
+  end
+
+  module ILF1
+  end
+
+  def _nt_i_LF
+    start_index = index
+    if node_cache[:i_LF].has_key?(index)
+      cached = node_cache[:i_LF][index]
+      if cached
+        node_cache[:i_LF][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?("\\n", false, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"\\\\n"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        i3, s3 = index, []
+        if (match_len = has_terminal?("\\u", false, index))
+          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"\\\\u"')
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          i5 = index
+          if (match_len = has_terminal?("000a", :insens, index))
+            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"000A"')
+            r6 = nil
+          end
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r5 = r6
+          else
+            i7, s7 = index, []
+            if (match_len = has_terminal?("{", false, index))
+              r8 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"{"')
+              r8 = nil
+            end
+            s7 << r8
+            if r8
+              s9, i9 = [], index
+              loop do
+                if (match_len = has_terminal?("0", false, index))
+                  r10 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"0"')
+                  r10 = nil
+                end
+                if r10
+                  s9 << r10
+                else
+                  break
+                end
+              end
+              r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+              s7 << r9
+              if r9
+                if (match_len = has_terminal?("a}", :insens, index))
+                  r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                  @index += match_len
+                else
+                  terminal_parse_failure('"A}"')
+                  r11 = nil
+                end
+                s7 << r11
+              end
+            end
+            if s7.last
+              r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+              r7.extend(ILF0)
+            else
+              @index = i7
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r5 = r7
+            else
+              @index = i5
+              r5 = nil
+            end
+          end
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(ILF1)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:i_LF][start_index] = r0
+
+    r0
+  end
+
+  module ICR0
+  end
+
+  module ICR1
+  end
+
+  def _nt_i_CR
+    start_index = index
+    if node_cache[:i_CR].has_key?(index)
+      cached = node_cache[:i_CR][index]
+      if cached
+        node_cache[:i_CR][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?("\r", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"\\r"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("\\r", false, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"\\\\r"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        i3, s3 = index, []
+        if (match_len = has_terminal?("\\u", false, index))
+          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"\\\\u"')
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          i5 = index
+          if (match_len = has_terminal?("000d", :insens, index))
+            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"000D"')
+            r6 = nil
+          end
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r5 = r6
+          else
+            i7, s7 = index, []
+            if (match_len = has_terminal?("{", false, index))
+              r8 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"{"')
+              r8 = nil
+            end
+            s7 << r8
+            if r8
+              s9, i9 = [], index
+              loop do
+                if (match_len = has_terminal?("0", false, index))
+                  r10 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"0"')
+                  r10 = nil
+                end
+                if r10
+                  s9 << r10
+                else
+                  break
+                end
+              end
+              r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+              s7 << r9
+              if r9
+                if (match_len = has_terminal?("d}", :insens, index))
+                  r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                  @index += match_len
+                else
+                  terminal_parse_failure('"D}"')
+                  r11 = nil
+                end
+                s7 << r11
+              end
+            end
+            if s7.last
+              r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+              r7.extend(ICR0)
+            else
+              @index = i7
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r5 = r7
+            else
+              @index = i5
+              r5 = nil
+            end
+          end
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(ICR1)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:i_CR][start_index] = r0
+
+    r0
+  end
+
+  module INONASCII0
+    def ESCGE7F
+      elements[1]
+    end
+  end
+
+  def _nt_i_NONASCII
+    start_index = index
+    if node_cache[:i_NONASCII].has_key?(index)
+      cached = node_cache[:i_NONASCII][index]
+      if cached
+        node_cache[:i_NONASCII][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_NONASCII
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i2, s2 = index, []
+      if (match_len = has_terminal?("\\u", false, index))
+        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"\\\\u"')
+        r3 = nil
+      end
+      s2 << r3
+      if r3
+        r4 = _nt_ESCGE7F
+        s2 << r4
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(INONASCII0)
+      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[:i_NONASCII][start_index] = r0
+
+    r0
+  end
+
+  module ESCGE7F0
+  end
+
+  module ESCGE7F1
+    def HEXDIG1
+      elements[1]
+    end
+
+  end
+
+  module ESCGE7F2
+    def TWOHEX1
+      elements[1]
+    end
+  end
+
+  module ESCGE7F3
+  end
+
+  module ESCGE7F4
+    def HEXDIG1
+      elements[0]
+    end
+
+  end
+
+  module ESCGE7F5
+    def HEXDIG1
+      elements[0]
+    end
+
+  end
+
+  module ESCGE7F6
+  end
+
+  def _nt_ESCGE7F
+    start_index = index
+    if node_cache[:ESCGE7F].has_key?(index)
+      cached = node_cache[:ESCGE7F][index]
+      if cached
+        node_cache[:ESCGE7F][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if (match_len = has_terminal?("d", :insens, index))
+      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"D"')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      i3 = index
+      if (match_len = has_terminal?("8", false, index))
+        r4 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"8"')
+        r4 = nil
+      end
+      if r4
+        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+        r3 = r4
+      else
+        if (match_len = has_terminal?("9", false, index))
+          r5 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"9"')
+          r5 = nil
+        end
+        if r5
+          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+          r3 = r5
+        else
+          if (match_len = has_terminal?("a", :insens, index))
+            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"A"')
+            r6 = nil
+          end
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r3 = r6
+          else
+            if (match_len = has_terminal?("b", :insens, index))
+              r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+              @index += match_len
+            else
+              terminal_parse_failure('"B"')
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r3 = r7
+            else
+              @index = i3
+              r3 = nil
+            end
+          end
+        end
+      end
+      s1 << r3
+      if r3
+        s8, i8 = [], index
+        loop do
+          r9 = _nt_HEXDIG
+          if r9
+            s8 << r9
+          else
+            break
+          end
+          if s8.size == 2
+            break
+          end
+        end
+        if s8.size < 2
+          @index = i8
+          r8 = nil
+        else
+          if s8.size < 2
+            @terminal_failures.pop
+          end
+          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+        end
+        s1 << r8
+        if r8
+          if (match_len = has_terminal?("\\u", false, index))
+            r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"\\\\u"')
+            r10 = nil
+          end
+          s1 << r10
+          if r10
+            if (match_len = has_terminal?("d", :insens, index))
+              r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+              @index += match_len
+            else
+              terminal_parse_failure('"D"')
+              r11 = nil
+            end
+            s1 << r11
+            if r11
+              i12 = index
+              if (match_len = has_terminal?("c", :insens, index))
+                r13 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                @index += match_len
+              else
+                terminal_parse_failure('"C"')
+                r13 = nil
+              end
+              if r13
+                r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
+                r12 = r13
+              else
+                if (match_len = has_terminal?("d", :insens, index))
+                  r14 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                  @index += match_len
+                else
+                  terminal_parse_failure('"D"')
+                  r14 = nil
+                end
+                if r14
+                  r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
+                  r12 = r14
+                else
+                  if (match_len = has_terminal?("e", :insens, index))
+                    r15 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                    @index += match_len
+                  else
+                    terminal_parse_failure('"E"')
+                    r15 = nil
+                  end
+                  if r15
+                    r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
+                    r12 = r15
+                  else
+                    if (match_len = has_terminal?("f", :insens, index))
+                      r16 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                      @index += match_len
+                    else
+                      terminal_parse_failure('"F"')
+                      r16 = nil
+                    end
+                    if r16
+                      r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
+                      r12 = r16
+                    else
+                      @index = i12
+                      r12 = nil
+                    end
+                  end
+                end
+              end
+              s1 << r12
+              if r12
+                s17, i17 = [], index
+                loop do
+                  r18 = _nt_HEXDIG
+                  if r18
+                    s17 << r18
+                  else
+                    break
+                  end
+                  if s17.size == 2
+                    break
+                  end
+                end
+                if s17.size < 2
+                  @index = i17
+                  r17 = nil
+                else
+                  if s17.size < 2
+                    @terminal_failures.pop
+                  end
+                  r17 = instantiate_node(SyntaxNode,input, i17...index, s17)
+                end
+                s1 << r17
+              end
+            end
+          end
+        end
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(ESCGE7F0)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r19 = _nt_FOURHEX1
+      if r19
+        r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
+        r0 = r19
+      else
+        i20, s20 = index, []
+        if (match_len = has_terminal?("0", false, index))
+          r21 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"0"')
+          r21 = nil
+        end
+        s20 << r21
+        if r21
+          r22 = _nt_HEXDIG1
+          s20 << r22
+          if r22
+            s23, i23 = [], index
+            loop do
+              r24 = _nt_HEXDIG
+              if r24
+                s23 << r24
+              else
+                break
+              end
+              if s23.size == 2
+                break
+              end
+            end
+            if s23.size < 2
+              @index = i23
+              r23 = nil
+            else
+              if s23.size < 2
+                @terminal_failures.pop
+              end
+              r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
+            end
+            s20 << r23
+          end
+        end
+        if s20.last
+          r20 = instantiate_node(SyntaxNode,input, i20...index, s20)
+          r20.extend(ESCGE7F1)
+        else
+          @index = i20
+          r20 = nil
+        end
+        if r20
+          r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
+          r0 = r20
+        else
+          i25, s25 = index, []
+          if (match_len = has_terminal?("00", false, index))
+            r26 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"00"')
+            r26 = nil
+          end
+          s25 << r26
+          if r26
+            r27 = _nt_TWOHEX1
+            s25 << r27
+          end
+          if s25.last
+            r25 = instantiate_node(SyntaxNode,input, i25...index, s25)
+            r25.extend(ESCGE7F2)
+          else
+            @index = i25
+            r25 = nil
+          end
+          if r25
+            r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
+            r0 = r25
+          else
+            i28, s28 = index, []
+            if (match_len = has_terminal?("{", false, index))
+              r29 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"{"')
+              r29 = nil
+            end
+            s28 << r29
+            if r29
+              s30, i30 = [], index
+              loop do
+                if (match_len = has_terminal?("0", false, index))
+                  r31 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"0"')
+                  r31 = nil
+                end
+                if r31
+                  s30 << r31
+                else
+                  break
+                end
+              end
+              r30 = instantiate_node(SyntaxNode,input, i30...index, s30)
+              s28 << r30
+              if r30
+                i32 = index
+                i33, s33 = index, []
+                if (match_len = has_terminal?("10", false, index))
+                  r34 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                  @index += match_len
+                else
+                  terminal_parse_failure('"10"')
+                  r34 = nil
+                end
+                s33 << r34
+                if r34
+                  s35, i35 = [], index
+                  loop do
+                    r36 = _nt_HEXDIG
+                    if r36
+                      s35 << r36
+                    else
+                      break
+                    end
+                    if s35.size == 4
+                      break
+                    end
+                  end
+                  if s35.size < 4
+                    @index = i35
+                    r35 = nil
+                  else
+                    if s35.size < 4
+                      @terminal_failures.pop
+                    end
+                    r35 = instantiate_node(SyntaxNode,input, i35...index, s35)
+                  end
+                  s33 << r35
+                end
+                if s33.last
+                  r33 = instantiate_node(SyntaxNode,input, i33...index, s33)
+                  r33.extend(ESCGE7F3)
+                else
+                  @index = i33
+                  r33 = nil
+                end
+                if r33
+                  r33 = SyntaxNode.new(input, (index-1)...index) if r33 == true
+                  r32 = r33
+                else
+                  i37, s37 = index, []
+                  r38 = _nt_HEXDIG1
+                  s37 << r38
+                  if r38
+                    s39, i39 = [], index
+                    loop do
+                      r40 = _nt_HEXDIG
+                      if r40
+                        s39 << r40
+                      else
+                        break
+                      end
+                      if s39.size == 4
+                        break
+                      end
+                    end
+                    if s39.size < 4
+                      @index = i39
+                      r39 = nil
+                    else
+                      if s39.size < 4
+                        @terminal_failures.pop
+                      end
+                      r39 = instantiate_node(SyntaxNode,input, i39...index, s39)
+                    end
+                    s37 << r39
+                  end
+                  if s37.last
+                    r37 = instantiate_node(SyntaxNode,input, i37...index, s37)
+                    r37.extend(ESCGE7F4)
+                  else
+                    @index = i37
+                    r37 = nil
+                  end
+                  if r37
+                    r37 = SyntaxNode.new(input, (index-1)...index) if r37 == true
+                    r32 = r37
+                  else
+                    r41 = _nt_FOURHEX1
+                    if r41
+                      r41 = SyntaxNode.new(input, (index-1)...index) if r41 == true
+                      r32 = r41
+                    else
+                      i42, s42 = index, []
+                      r43 = _nt_HEXDIG1
+                      s42 << r43
+                      if r43
+                        s44, i44 = [], index
+                        loop do
+                          r45 = _nt_HEXDIG
+                          if r45
+                            s44 << r45
+                          else
+                            break
+                          end
+                          if s44.size == 2
+                            break
+                          end
+                        end
+                        if s44.size < 2
+                          @index = i44
+                          r44 = nil
+                        else
+                          if s44.size < 2
+                            @terminal_failures.pop
+                          end
+                          r44 = instantiate_node(SyntaxNode,input, i44...index, s44)
+                        end
+                        s42 << r44
+                      end
+                      if s42.last
+                        r42 = instantiate_node(SyntaxNode,input, i42...index, s42)
+                        r42.extend(ESCGE7F5)
+                      else
+                        @index = i42
+                        r42 = nil
+                      end
+                      if r42
+                        r42 = SyntaxNode.new(input, (index-1)...index) if r42 == true
+                        r32 = r42
+                      else
+                        r46 = _nt_TWOHEX1
+                        if r46
+                          r46 = SyntaxNode.new(input, (index-1)...index) if r46 == true
+                          r32 = r46
+                        else
+                          @index = i32
+                          r32 = nil
+                        end
+                      end
+                    end
+                  end
+                end
+                s28 << r32
+                if r32
+                  if (match_len = has_terminal?("}", false, index))
+                    r47 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('"}"')
+                    r47 = nil
+                  end
+                  s28 << r47
+                end
+              end
+            end
+            if s28.last
+              r28 = instantiate_node(SyntaxNode,input, i28...index, s28)
+              r28.extend(ESCGE7F6)
+            else
+              @index = i28
+              r28 = nil
+            end
+            if r28
+              r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
+              r0 = r28
+            else
+              @index = i0
+              r0 = nil
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:ESCGE7F][start_index] = r0
+
+    r0
+  end
+
+  module FOURHEX10
+  end
+
+  module FOURHEX11
+    def ODIGIT
+      elements[1]
+    end
+
+  end
+
+  def _nt_FOURHEX1
+    start_index = index
+    if node_cache[:FOURHEX1].has_key?(index)
+      cached = node_cache[:FOURHEX1][index]
+      if cached
+        node_cache[:FOURHEX1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    i2 = index
+    r3 = _nt_DIGIT1
+    if r3
+      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+      r2 = r3
+    else
+      if (match_len = has_terminal?("a", :insens, index))
+        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"A"')
+        r4 = nil
+      end
+      if r4
+        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+        r2 = r4
+      else
+        if (match_len = has_terminal?("b", :insens, index))
+          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"B"')
+          r5 = nil
+        end
+        if r5
+          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+          r2 = r5
+        else
+          if (match_len = has_terminal?("c", :insens, index))
+            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"C"')
+            r6 = nil
+          end
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r2 = r6
+          else
+            if (match_len = has_terminal?("e", :insens, index))
+              r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+              @index += match_len
+            else
+              terminal_parse_failure('"E"')
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r2 = r7
+            else
+              if (match_len = has_terminal?("f", :insens, index))
+                r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                @index += match_len
+              else
+                terminal_parse_failure('"F"')
+                r8 = nil
+              end
+              if r8
+                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                r2 = r8
+              else
+                @index = i2
+                r2 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+    s1 << r2
+    if r2
+      s9, i9 = [], index
+      loop do
+        r10 = _nt_HEXDIG
+        if r10
+          s9 << r10
+        else
+          break
+        end
+        if s9.size == 3
+          break
+        end
+      end
+      if s9.size < 3
+        @index = i9
+        r9 = nil
+      else
+        if s9.size < 3
+          @terminal_failures.pop
+        end
+        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+      end
+      s1 << r9
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(FOURHEX10)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i11, s11 = index, []
+      if (match_len = has_terminal?("d", :insens, index))
+        r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"D"')
+        r12 = nil
+      end
+      s11 << r12
+      if r12
+        r13 = _nt_ODIGIT
+        s11 << r13
+        if r13
+          s14, i14 = [], index
+          loop do
+            r15 = _nt_HEXDIG
+            if r15
+              s14 << r15
+            else
+              break
+            end
+            if s14.size == 2
+              break
+            end
+          end
+          if s14.size < 2
+            @index = i14
+            r14 = nil
+          else
+            if s14.size < 2
+              @terminal_failures.pop
+            end
+            r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
+          end
+          s11 << r14
+        end
+      end
+      if s11.last
+        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+        r11.extend(FOURHEX11)
+      else
+        @index = i11
+        r11 = nil
+      end
+      if r11
+        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+        r0 = r11
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:FOURHEX1][start_index] = r0
+
+    r0
+  end
+
+  module TWOHEX10
+    def HEXDIG
+      elements[1]
+    end
+  end
+
+  def _nt_TWOHEX1
+    start_index = index
+    if node_cache[:TWOHEX1].has_key?(index)
+      cached = node_cache[:TWOHEX1][index]
+      if cached
+        node_cache[:TWOHEX1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    i2 = index
+    if (match_len = has_terminal?("8", false, index))
+      r3 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"8"')
+      r3 = nil
+    end
+    if r3
+      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+      r2 = r3
+    else
+      if (match_len = has_terminal?("9", false, index))
+        r4 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"9"')
+        r4 = nil
+      end
+      if r4
+        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+        r2 = r4
+      else
+        r5 = _nt_HEXDIGA
+        if r5
+          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+          r2 = r5
+        else
+          @index = i2
+          r2 = nil
+        end
+      end
+    end
+    s1 << r2
+    if r2
+      r6 = _nt_HEXDIG
+      s1 << r6
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(TWOHEX10)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("7f", :insens, index))
+        r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"7F"')
+        r7 = nil
+      end
+      if r7
+        r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+        r0 = r7
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:TWOHEX1][start_index] = r0
 
     r0
   end
 
-  def _nt_SQUOTE
+  module SqAppStringH0
+    def app_string_h
+      elements[1]
+    end
+
+  end
+
+  module SqAppStringH1
+    def ast; app_string_h.ast end
+  end
+
+  def _nt_sq_app_string_h
     start_index = index
-    if node_cache[:SQUOTE].has_key?(index)
-      cached = node_cache[:SQUOTE][index]
+    if node_cache[:sq_app_string_h].has_key?(index)
+      cached = node_cache[:sq_app_string_h][index]
       if cached
-        node_cache[:SQUOTE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:sq_app_string_h][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))
+    i0, s0 = index, []
+    if (match_len = has_terminal?("h'", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
       @index += match_len
     else
-      terminal_parse_failure('"\'"')
+      terminal_parse_failure('"h\'"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_app_string_h
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?("'", false, index))
+          r3 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"\'"')
+          r3 = nil
+        end
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(SqAppStringH0)
+      r0.extend(SqAppStringH1)
+    else
+      @index = i0
       r0 = nil
     end
 
-    node_cache[:SQUOTE][start_index] = r0
+    node_cache[:sq_app_string_h][start_index] = r0
 
     r0
   end
 
-  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
+  module AppStringH0
+    def HEXDIG1
+      elements[0]
     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
+    def h_S1
+      elements[1]
     end
 
-    node_cache[:DIGIT][start_index] = r0
+    def HEXDIG2
+      elements[2]
+    end
 
-    r0
+    def h_S2
+      elements[3]
+    end
   end
 
-  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
+  module AppStringH1
+    def ast
+      Integer(elements[0].text_value + elements[2].text_value, 16).chr("BINARY")
     end
+  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
+  module AppStringH2
+    def ellipsis
+      elements[0]
     end
 
-    node_cache[:DIGIT1][start_index] = r0
+    def h_S
+      elements[1]
+    end
+  end
 
-    r0
+  module AppStringH3
+    def ast; ellipsis.ast end
   end
 
-  def _nt_ODIGIT
+  module AppStringH4
+  end
+
+  module AppStringH5
+    def h_S
+      elements[0]
+    end
+
+  end
+
+  module AppStringH6
+    def unpack_thread(s)
+      case s[0]
+      when CBOR::Tagged
+        s[0]
+      when String
+        s.join
+      else
+        raise "@@@ unpack_thread #{s.inspect}"
+      end
+    end
+    def ast
+      e1 = elements[1].elements.map {|e| e.ast}
+      out = []
+      curr = []
+      e1.each { |el|
+        if curr.size == 0 || curr[0].class == el.class
+          curr << el
+        else
+          out << curr
+          curr = [el]
+        end
+      }
+      if out.size == 0 && (curr.size == 0 || String === curr[0])
+        curr.join.b # unpack_thread(curr)
+      else
+        CBOR::Tagged.new(888, (out << curr).map {|x| unpack_thread(x)})
+      end
+    end
+  end
+
+  def _nt_app_string_h
     start_index = index
-    if node_cache[:ODIGIT].has_key?(index)
-      cached = node_cache[:ODIGIT][index]
+    if node_cache[:app_string_h].has_key?(index)
+      cached = node_cache[:app_string_h][index]
       if cached
-        node_cache[:ODIGIT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:app_string_h][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-7]'] ||= Regexp.new(gr), :regexp, index)
-      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
+    i0, s0 = index, []
+    r1 = _nt_h_S
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3 = index
+        i4, s4 = index, []
+        r5 = _nt_HEXDIG
+        s4 << r5
+        if r5
+          r6 = _nt_h_S
+          s4 << r6
+          if r6
+            r7 = _nt_HEXDIG
+            s4 << r7
+            if r7
+              r8 = _nt_h_S
+              s4 << r8
+            end
+          end
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(AppStringH0)
+          r4.extend(AppStringH1)
+        else
+          @index = i4
+          r4 = nil
+        end
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r3 = r4
+        else
+          i9, s9 = index, []
+          r10 = _nt_ellipsis
+          s9 << r10
+          if r10
+            r11 = _nt_h_S
+            s9 << r11
+          end
+          if s9.last
+            r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+            r9.extend(AppStringH2)
+            r9.extend(AppStringH3)
+          else
+            @index = i9
+            r9 = nil
+          end
+          if r9
+            r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+            r3 = r9
+          else
+            @index = i3
+            r3 = nil
+          end
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        i13, s13 = index, []
+        if (match_len = has_terminal?("#", false, index))
+          r14 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"#"')
+          r14 = nil
+        end
+        s13 << r14
+        if r14
+          s15, i15 = [], index
+          loop do
+            r16 = _nt_h_non_lf
+            if r16
+              s15 << r16
+            else
+              break
+            end
+          end
+          r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+          s13 << r15
+        end
+        if s13.last
+          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+          r13.extend(AppStringH4)
+        else
+          @index = i13
+          r13 = nil
+        end
+        if r13
+          r12 = r13
+        else
+          r12 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r12
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AppStringH5)
+      r0.extend(AppStringH6)
     else
-      terminal_parse_failure('[0-7]')
+      @index = i0
       r0 = nil
     end
 
-    node_cache[:ODIGIT][start_index] = r0
+    node_cache[:app_string_h][start_index] = r0
 
     r0
   end
 
-  def _nt_BDIGIT
+  def _nt_h_blank
     start_index = index
-    if node_cache[:BDIGIT].has_key?(index)
-      cached = node_cache[:BDIGIT][index]
+    if node_cache[:h_blank].has_key?(index)
+      cached = node_cache[:h_blank][index]
       if cached
-        node_cache[:BDIGIT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:h_blank][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
+    i0 = index
+    r1 = _nt_i_HT
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
     else
-      terminal_parse_failure('[0-1]')
-      r0 = nil
+      r2 = _nt_i_LF
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        r3 = _nt_i_CR
+        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[:BDIGIT][start_index] = r0
+    node_cache[:h_blank][start_index] = r0
 
     r0
   end
 
-  def _nt_HEXDIG
+  def _nt_h_non_slash
     start_index = index
-    if node_cache[:HEXDIG].has_key?(index)
-      cached = node_cache[:HEXDIG][index]
+    if node_cache[:h_non_slash].has_key?(index)
+      cached = node_cache[:h_non_slash][index]
       if cached
-        node_cache[:HEXDIG][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:h_non_slash][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0 = index
-    r1 = _nt_DIGIT
+    r1 = _nt_h_blank
     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
+      if has_terminal?(@regexps[gr = '\A[!-&]'] ||= Regexp.new(gr), :regexp, index)
+        r2 = true
+        @index += 1
       else
-        terminal_parse_failure('"A"')
+        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?("b", :insens, index))
+        if (match_len = has_terminal?("\\'", false, index))
           r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
           @index += match_len
         else
-          terminal_parse_failure('"B"')
+          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?("c", :insens, index))
-            r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-            @index += match_len
+          if has_terminal?(@regexps[gr = '\A[\\(-\\.]'] ||= Regexp.new(gr), :regexp, index)
+            r4 = true
+            @index += 1
           else
-            terminal_parse_failure('"C"')
+            terminal_parse_failure('[\\(-\\.]')
             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
+            if has_terminal?(@regexps[gr = '\A[0-\\[]'] ||= Regexp.new(gr), :regexp, index)
+              r5 = true
+              @index += 1
             else
-              terminal_parse_failure('"D"')
+              terminal_parse_failure('[0-\\[]')
               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))
+              if (match_len = has_terminal?("\\\\", false, index))
                 r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                 @index += match_len
               else
-                terminal_parse_failure('"E"')
+                terminal_parse_failure('"\\\\\\\\"')
                 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
+                if has_terminal?(@regexps[gr = '\A[\\]-]'] ||= Regexp.new(gr), :regexp, index)
+                  r7 = true
+                  @index += 1
                 else
-                  terminal_parse_failure('"F"')
+                  terminal_parse_failure('[\\]-]')
                   r7 = nil
                 end
                 if r7
                   r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                   r0 = r7
                 else
-                  @index = i0
-                  r0 = nil
+                  r8 = _nt_i_NONASCII
+                  if r8
+                    r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                    r0 = r8
+                  else
+                    @index = i0
+                    r0 = nil
+                  end
                 end
               end
             end
@@ -4862,96 +7592,96 @@ module EDNGRAMMAR
       end
     end
 
-    node_cache[:HEXDIG][start_index] = r0
+    node_cache[:h_non_slash][start_index] = r0
 
     r0
   end
 
-  def _nt_HEXDIG1
+  def _nt_h_non_lf
     start_index = index
-    if node_cache[:HEXDIG1].has_key?(index)
-      cached = node_cache[:HEXDIG1][index]
+    if node_cache[:h_non_lf].has_key?(index)
+      cached = node_cache[:h_non_lf][index]
       if cached
-        node_cache[:HEXDIG1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:h_non_lf][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0 = index
-    r1 = _nt_DIGIT1
+    r1 = _nt_i_HT
     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
+      r2 = _nt_i_CR
       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
+        if has_terminal?(@regexps[gr = '\A[\\ -&]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
         else
-          terminal_parse_failure('"B"')
+          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?("c", :insens, index))
+          if (match_len = has_terminal?("\\'", false, index))
             r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
             @index += match_len
           else
-            terminal_parse_failure('"C"')
+            terminal_parse_failure('"\\\\\'"')
             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
+            if has_terminal?(@regexps[gr = '\A[\\(-\\[]'] ||= Regexp.new(gr), :regexp, index)
+              r5 = true
+              @index += 1
             else
-              terminal_parse_failure('"D"')
+              terminal_parse_failure('[\\(-\\[]')
               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))
+              if (match_len = has_terminal?("\\\\", false, index))
                 r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                 @index += match_len
               else
-                terminal_parse_failure('"E"')
+                terminal_parse_failure('"\\\\\\\\"')
                 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
+                if has_terminal?(@regexps[gr = '\A[\\]-]'] ||= Regexp.new(gr), :regexp, index)
+                  r7 = true
+                  @index += 1
                 else
-                  terminal_parse_failure('"F"')
+                  terminal_parse_failure('[\\]-]')
                   r7 = nil
                 end
                 if r7
                   r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                   r0 = r7
                 else
-                  @index = i0
-                  r0 = nil
+                  r8 = _nt_i_NONASCII
+                  if r8
+                    r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                    r0 = r8
+                  else
+                    @index = i0
+                    r0 = nil
+                  end
                 end
               end
             end
@@ -4960,163 +7690,199 @@ module EDNGRAMMAR
       end
     end
 
-    node_cache[:HEXDIG1][start_index] = r0
+    node_cache[:h_non_lf][start_index] = r0
 
     r0
   end
 
-  def _nt_lcalpha
-    start_index = index
-    if node_cache[:lcalpha].has_key?(index)
-      cached = node_cache[:lcalpha][index]
-      if cached
-        node_cache[:lcalpha][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    if has_terminal?(@regexps[gr = '\A[a-z]'] ||= Regexp.new(gr), :regexp, index)
-      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('[a-z]')
-      r0 = nil
+  module HS0
+    def h_comment
+      elements[0]
     end
 
-    node_cache[:lcalpha][start_index] = r0
+  end
 
-    r0
+  module HS1
   end
 
-  def _nt_lcalnum
+  def _nt_h_S
     start_index = index
-    if node_cache[:lcalnum].has_key?(index)
-      cached = node_cache[:lcalnum][index]
+    if node_cache[:h_S].has_key?(index)
+      cached = node_cache[:h_S][index]
       if cached
-        node_cache[:lcalnum][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:h_S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
-    i0 = index
-    r1 = _nt_lcalpha
-    if r1
-      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
-      r0 = r1
-    else
-      r2 = _nt_DIGIT
+    i0, s0 = index, []
+    s1, i1 = [], index
+    loop do
+      r2 = _nt_h_blank
       if r2
-        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-        r0 = r2
+        s1 << r2
       else
-        @index = i0
-        r0 = nil
+        break
       end
     end
-
-    node_cache[:lcalnum][start_index] = r0
-
-    r0
-  end
-
-  def _nt_ucalpha
-    start_index = index
-    if node_cache[:ucalpha].has_key?(index)
-      cached = node_cache[:ucalpha][index]
-      if cached
-        node_cache[:ucalpha][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+    s0 << r1
+    if r1
+      s3, i3 = [], index
+      loop do
+        i4, s4 = index, []
+        r5 = _nt_h_comment
+        s4 << r5
+        if r5
+          s6, i6 = [], index
+          loop do
+            r7 = _nt_h_blank
+            if r7
+              s6 << r7
+            else
+              break
+            end
+          end
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          s4 << r6
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(HS0)
+        else
+          @index = i4
+          r4 = nil
+        end
+        if r4
+          s3 << r4
+        else
+          break
+        end
       end
-      return cached
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s0 << r3
     end
-
-    if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
-      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(HS1)
     else
-      terminal_parse_failure('[A-Z]')
+      @index = i0
       r0 = nil
     end
 
-    node_cache[:ucalpha][start_index] = r0
+    node_cache[:h_S][start_index] = r0
 
     r0
   end
 
-  def _nt_ucalnum
-    start_index = index
-    if node_cache[:ucalnum].has_key?(index)
-      cached = node_cache[:ucalnum][index]
-      if cached
-        node_cache[:ucalnum][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
+  module HComment0
+  end
 
-    i0 = index
-    r1 = _nt_ucalpha
-    if r1
-      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
-      r0 = r1
-    else
-      r2 = _nt_DIGIT
-      if r2
-        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-        r0 = r2
-      else
-        @index = i0
-        r0 = nil
-      end
+  module HComment1
+    def i_LF
+      elements[2]
     end
-
-    node_cache[:ucalnum][start_index] = r0
-
-    r0
   end
 
-  def _nt_wordchar
+  def _nt_h_comment
     start_index = index
-    if node_cache[:wordchar].has_key?(index)
-      cached = node_cache[:wordchar][index]
+    if node_cache[:h_comment].has_key?(index)
+      cached = node_cache[:h_comment][index]
       if cached
-        node_cache[:wordchar][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:h_comment][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0 = index
-    if (match_len = has_terminal?("_", false, index))
-      r1 = true
+    i1, s1 = index, []
+    if (match_len = has_terminal?("/", false, index))
+      r2 = true
       @index += match_len
     else
-      terminal_parse_failure('"_"')
+      terminal_parse_failure('"/"')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      s3, i3 = [], index
+      loop do
+        r4 = _nt_h_non_slash
+        if r4
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s1 << r3
+      if r3
+        if (match_len = has_terminal?("/", false, index))
+          r5 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"/"')
+          r5 = nil
+        end
+        s1 << r5
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(HComment0)
+    else
+      @index = i1
       r1 = nil
     end
     if r1
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
     else
-      r2 = _nt_lcalnum
-      if r2
-        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-        r0 = r2
+      i6, s6 = index, []
+      if (match_len = has_terminal?("#", false, index))
+        r7 = true
+        @index += match_len
       else
-        r3 = _nt_ucalpha
-        if r3
-          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-          r0 = r3
-        else
-          @index = i0
-          r0 = nil
+        terminal_parse_failure('"#"')
+        r7 = nil
+      end
+      s6 << r7
+      if r7
+        s8, i8 = [], index
+        loop do
+          r9 = _nt_h_non_lf
+          if r9
+            s8 << r9
+          else
+            break
+          end
+        end
+        r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+        s6 << r8
+        if r8
+          r10 = _nt_i_LF
+          s6 << r10
         end
       end
+      if s6.last
+        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+        r6.extend(HComment1)
+      else
+        @index = i6
+        r6 = nil
+      end
+      if r6
+        r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+        r0 = r6
+      else
+        @index = i0
+        r0 = nil
+      end
     end
 
-    node_cache[:wordchar][start_index] = r0
+    node_cache[:h_comment][start_index] = r0
 
     r0
   end