nyacc: Update to 0.78.
authorJan Nieuwenhuizen <janneke@gnu.org>
Sat, 6 May 2017 20:35:46 +0000 (22:35 +0200)
committerJan Nieuwenhuizen <janneke@gnu.org>
Sat, 6 May 2017 20:35:46 +0000 (22:35 +0200)
20 files changed:
module/nyacc/ChangeLog
module/nyacc/lalr.scm
module/nyacc/lalr2.scm [new file with mode: 0644]
module/nyacc/lang/c99/BUGS
module/nyacc/lang/c99/body.scm
module/nyacc/lang/c99/cpp.scm
module/nyacc/lang/c99/cppmach.scm
module/nyacc/lang/c99/mach.d/c99tab.scm
module/nyacc/lang/c99/mach.d/c99xtab.scm
module/nyacc/lang/c99/mach.d/cpptab.scm
module/nyacc/lang/c99/mach.scm
module/nyacc/lang/c99/parser.scm
module/nyacc/lang/c99/pprint.scm
module/nyacc/lang/c99/util1.scm
module/nyacc/lang/c99/util2.scm
module/nyacc/lang/c99/xparser.scm
module/nyacc/lang/util.scm
module/nyacc/lex.scm
module/nyacc/parse.scm
module/nyacc/util.scm

index a347f50711a41d851908b1507684140f08676123..f2a7b5a68c14fbe5e66184218541c6072ec83250 100644 (file)
@@ -1,3 +1,26 @@
+2017-05-06  Matt Wette  <mwette@alumni.caltech.edu>
+
+       * lalr.scm: updated write-lalr-tables and write-lalr-actions to
+       accept a prefix string
+
+2017-05-04  Matt Wette  <mwette@alumni.caltech.edu>
+
+       * lang/c99/pprint.scm (pretty-print-c99): removed double spacing
+       in printed declarations
+
+       * lang/util.scm (make-pp-formatter): fixed bug in column counting
+       that prevented line-wrap to occur.
+
+2017-04-12  Matt Wette  <mwette@alumni.caltech.edu>
+
+       * lex.scm (make-comm-reader): comments which end in newline can
+       now also end in #<eof>
+
+2017-03-11  Matt Wette  <mwette@alumni.caltech.edu>
+
+       * lang/c99/parser.scm (parse-c99): added mode keyword argument to
+       gen-c-lexer, file mode would not have been working ...
+
 2017-03-03  Matt Wette  <mwette@alumni.caltech.edu>
 
        * lalr.scm: added "keepers" keyword argument to compact-machine
index 6b032f53e37df93b575d63547170d98aed282548..6f4c7b35ce97610d7ec534cc7f705b07331b1ee7 100644 (file)
 ;;; You should have received a copy of the GNU Lesser General Public License
 ;;; along with this library; if not, see <http://www.gnu.org/licenses/>
 
-(cond-expand
- (guile-2)
- (guile
-  (use-modules (ice-9 syncase))
-  (use-modules (ice-9 optargs)))
- (mes))
-
 ;; I need to find way to preserve srconf, rrconf after hashify.
 ;; compact needs to deal with it ...
 
@@ -49,8 +42,7 @@
   #:use-module (nyacc util)
   )
 
-(define *nyacc-version* "0.76.5+jsdev")
-
+(define *nyacc-version* "0.78.0")
 
 ;; @deffn proxy-? sym rhs
 ;; @example
        (regexp-substitute #f m 'pre repl 'post)
        str)))
 
-;; @deffn {Procedure} write-lalr-tables mach filename [#:lang output-lang]
+;; @deffn {Procedure} write-lalr-tables mach filename [optons]
+;; Options are
+;; @table code
+;; @item #:prefix prefix-string
+;; The prefix for generating table names.  The default is @code{""}.
+;; @item #:lang output-lang-symbol
+;; This specifies the output language.  Currently only the default
+;; @code{'scheme} is supported.
+;; @end table
+;; @noindent 
 ;; For example,
 ;; @example
 ;; write-lalr-tables mach "tables.scm"
 ;; write-lalr-tables mach "tables.tcl" #:lang 'tcl
 ;; @end example
 ;; @end deffn
-(define* (write-lalr-tables mach filename #:key (lang 'scheme))
+(define* (write-lalr-tables mach filename #:key (lang 'scheme) (prefix ""))
 
   (define (write-table mach name port)
-    (fmt port "(define ~A\n  " name)
+    (fmt port "(define ~A~A\n  " prefix name)
     (ugly-print (assq-ref mach name) port)
     (fmt port ")\n\n"))
 
 ;; write-lalr-actions mach "actions.tcl" #:lang 'tcl
 ;; @end example
 ;; @end deffn
-(define* (write-lalr-actions mach filename #:key (lang 'scheme))
+(define* (write-lalr-actions mach filename #:key (lang 'scheme) (prefix ""))
 
   (define (pp-rule/ts gx)
     (let* ((core (fluid-ref *lalr-core*))
     (with-fluid*
      *lalr-core* (make-core mach)
      (lambda ()
-       (fmt port "(define act-v\n  (vector\n")
+       (fmt port "(define ~Aact-v\n  (vector\n" prefix)
        (vector-for-each
        (lambda (gx actn)
          (fmt port "   ;; ~A\n" (pp-rule/ts gx))
diff --git a/module/nyacc/lalr2.scm b/module/nyacc/lalr2.scm
new file mode 100644 (file)
index 0000000..3dfbe05
--- /dev/null
@@ -0,0 +1,242 @@
+(add-to-load-path "/Users/mwette/repo/sv/nyacc-master/module")
+;;; system/base/lalr2.scm
+;;;
+;;; Copyright (C) 2014-2017 Matthew R. Wette
+;;;
+;;; This library is free software; you can redistribute it and/or
+;;; modify it under the terms of the GNU Lesser General Public
+;;; License as published by the Free Software Foundation; either
+;;; version 3 of the License, or (at your option) any later version.
+;;;
+;;; This library is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;;; Lesser General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU Lesser General Public License
+;;; along with this library; if not, see <http://www.gnu.org/licenses/>
+
+;; I need to find way to preserve srconf, rrconf after hashify.
+;; compact needs to deal with it ...
+
+;;(define-module (system base lalr2)
+(define-module (nyacc lalr2)
+  #:export-syntax (lalr2-spec)
+  #:export (*lalr2-version*
+           )
+  #:use-module ((srfi srfi-1) #:select (fold fold-right remove lset-union
+                                            lset-intersection lset-difference))
+  #:use-module ((srfi srfi-9) #:select (define-record-type))
+  #:use-module ((srfi srfi-43) #:select (vector-map vector-for-each vector-any))
+  #:use-module (nyacc util) ;; fmt fmtstr
+  )
+(use-modules (ice-9 pretty-print))
+
+(define *lalr2-version* "0.01.0")
+
+(define (fmtstr fmt . args)
+  (apply simple-format #f fmt args))
+(define (fmterr fmt . args)
+  (apply simple-format #t fmt args))
+(define (fmtout fmt . args)
+  (apply simple-format #t fmt args))
+(define fmt simple-format)
+
+;; @deffn reserved? grammar-symbol
+;; Determine whether the syntax argument is a reserved symbol, that is.
+;; So instead of writing @code{'$fixed} for syntax one can write
+;; @code{$fixed}.  We may want to change this to
+;; @example
+;; (reserved-terminal? grammar-symbol)
+;; (reserved-non-term? grammar-symbol)
+;; @end example
+(define (reserved? grammar-symbol)
+  ;; If the first character `$' then it's reserved.
+  (eqv? #\$ (string-ref (symbol->string (syntax->datum grammar-symbol)) 0)))
+  
+;; @deffn {Syntax} lalr2-spec grammar => spec
+;; This routine reads a grammar in a scheme-like syntax and returns an a-list.
+;; @end deffn
+(define-syntax lalr2-spec
+  (syntax-rules +++ () 
+    ((_ <expr> +++)
+     (letrec-syntax
+        ((parse-rhs
+          (lambda (x)
+            ;; The following is syntax-case because we use a fender.
+            (syntax-case x (quote $$ $prec $empty)
+              ;; action specifications
+              ((_ ($$ <guts> ...) <e2> ...)
+               #'(cons '(action #f <guts> ...) (parse-rhs <e2> ...)))
+              ;; other internal $-syntax
+              ((_ ($prec <tok>) <e2> ...)
+               #'(cons (cons 'prec (tokenize <tok>)) (parse-rhs <e2> ...)))
+              ((_ $empty <e2> ...)     ; TODO: propagate to processor
+               #'(cons '(empty) (parse-rhs <e2> ...)))
+              ;; terminals and non-terminals
+              ((_ (quote <e1>) <e2> ...)
+               #'(cons '(terminal . <e1>) (parse-rhs <e2> ...)))
+              ((_ (<f> ...) <e2> ...)
+               #'(cons (<f> ...) (parse-rhs <e2> ...)))
+              ((_ <e1> <e2> ...)
+               (identifier? (syntax <e1>)) ; fender to trap non-terminals
+               (if (reserved? (syntax <e1>))
+                   #'(cons '(terminal . <e1>) (parse-rhs <e2> ...))
+                   #'(cons '(non-terminal . <e1>) (parse-rhs <e2> ...))))
+              ((_ <e1> <e2> ...)
+               #'(cons '(terminal . <e1>) (parse-rhs <e2> ...)))
+              ((_) #'(list)))))
+         (parse-rhs-list
+          (syntax-rules ()
+            ((_ (<ex> ...) <rhs> ...)
+             (cons (parse-rhs <ex> ...) (parse-rhs-list <rhs> ...)))
+            ((_) '())))
+         (parse-grammar
+          (syntax-rules ()
+            ((_ (<lhs> <rhs> ...) <prod> ...)
+             (cons (cons '<lhs> (parse-rhs-list <rhs> ...))
+                   (parse-grammar <prod> ...)))
+            ((_) '())))
+         (tokenize
+          (lambda (x)
+            (syntax-case x ()
+              ((_ <tk>) (identifier? (syntax <tk>)) #'(quote <tk>))
+              ((_ <tk>) #'<tk>))))
+         (tokenize-list
+          (syntax-rules ()
+            ((_ <tk1> <tk2> ...)
+             (cons (tokenize <tk1>) (tokenize-list <tk2> ...)))
+            ((_) '())))
+         (parse-precedence
+          (syntax-rules (left right nonassoc)
+            ((_ (left <tk> ...) <ex> ...)
+             (cons (cons 'left (tokenize-list <tk> ...))
+                   (parse-precedence <ex> ...)))
+            ((_ (right <tk> ...) <ex> ...)
+             (cons (cons 'right (tokenize-list <tk> ...))
+                   (parse-precedence <ex> ...)))
+            ((_ (nonassoc <tk> ...) <ex> ...)
+             (cons (cons 'nonassoc (tokenize-list <tk> ...))
+                   (parse-precedence <ex> ...)))
+            ((_ <tk> <ex> ...)
+             (cons (list 'undecl (tokenize <tk>))
+                   (parse-precedence <ex> ...)))
+            ((_) '())))
+         (lalr-spec-1
+          (syntax-rules (start expect notice prec< prec> grammar)
+            ((_ (start <symb>) <e> ...)
+             (cons (cons 'start '<symb>) (lalr-spec-1 <e> ...)))
+            ((_ (expect <n>) <e> ...)
+             (cons (cons 'expect <n>) (lalr-spec-1 <e> ...)))
+            ((_ (notice <str>) <e> ...)
+             (cons (cons 'notice <str>) (lalr-spec-1 <e> ...)))
+            ((_ (prec< <ex> ...) <e> ...)
+             (cons (cons 'precedence (parse-precedence <ex> ...))
+                   (lalr-spec-1 <e> ...)))
+            ((_ (prec> <ex> ...) <e> ...)
+             (cons (cons 'precedence (reverse (parse-precedence <ex> ...)))
+                   (lalr-spec-1 <e> ...)))
+            ((_ (grammar <prod> ...) <e> ...)
+             (cons (cons 'grammar (parse-grammar <prod> ...))
+                   (lalr-spec-1 <e> ...))) 
+            ((_) '()))))
+       (identity (lalr-spec-1 <expr> +++))))))
+
+;; @deffn atomize terminal => object
+;; Generate an atomic object for a terminal.   Expected terminals are strings,
+;; characters and symbols.  This will convert the strings @code{s} to symbols
+;; of the form @code{'$:s}.
+(define (atomize terminal)
+  (if (string? terminal)
+      (string->symbol (string-append "$:" terminal))
+      terminal))
+
+(define (process-spec tree)
+
+  ;; Make a new symbol. This is a helper for proxies and mid-rule-actions.
+  ;; The counter here is the only @code{set!} in @code{process-spec}.
+  ;; Otherwise, I believe @code{process-spec} is referentially transparent.
+  (define maksy
+    (let ((cntr 1))
+      (lambda ()
+       (let ((c cntr))
+         (set! cntr (1+ cntr))
+         (string->symbol (string-append "$P" (number->string c)))))))
+
+  ;; Canonicalize precedence and associativity. Precedence will appear
+  ;; as sets of equivalent items in increasing order of precedence
+  ;; (e.g., @code{((+ -) (* /)}).  The input tree has nodes that look like
+  ;; @example
+  ;; '(precedence (left "+" "-") (left "*" "/"))
+  ;; '(precedence ('then "else")
+  ;; @end example
+  ;; @noindent
+  ;; =>
+  ;; @example
+  ;; (prec ((+ -) (* /)) ((then) (else)))
+  ;; @end example
+  (define (prec-n-assc tree)
+    ;; prec-l; lt-assc-l rt-assc-l non-assc-l pspec
+    (let iter ((pll '()) (pl '()) (la '()) (ra '()) (na '())
+              (spec '()) (tree tree))
+      (cond
+       ((pair? spec)
+       ;; item ~ ('left "+" "-") => a ~ 'left, tl ~ (#\+ #\-)
+       (let* ((item (car spec)) (as (car item)) (tl (map atomize (cdr item))))
+         (case as
+           ((left)
+            (iter pll (cons tl pl) (append tl la) ra na (cdr spec) tree))
+           ((right)
+            (iter pll (cons tl pl) la (append tl ra) na (cdr spec) tree))
+           ((nonassoc)
+            (iter pll (cons tl pl) la ra (append tl na) (cdr spec) tree))
+           ((undecl)
+            (iter pll (cons tl pl) la ra na (cdr spec) tree)))))
+       ((pair? pl)
+       (iter (cons (reverse pl) pll) '() la ra na spec tree))
+       ((pair? tree)
+       (iter pll pl la ra na
+             (if (eqv? 'precedence (caar tree)) (cdar tree) '()) (cdr tree)))
+       (else
+       (list
+        `(prec . ,(reverse pll))
+        `(assc (left ,@la) (right ,@ra) (nonassoc ,@na)))))))
+
+  (let* ((gram (assq-ref tree 'grammar))
+        (start-symbol (and=> (assq-ref tree 'start) atomize))
+        (start-rule (lambda () (list start-symbol)))
+        (add-el (lambda (e l) (if (member e l) l (cons e l))))
+        (pna (prec-n-assc tree)))
+    ;; We sweep through the grammar to generate a canonical specification.
+    ;; Note: the local rhs is used to hold RHS terms, but a
+    ;; value of @code{'()} is used to signal "add rule", and a value of
+    ;; @code{#f} is used to signal ``done, proceed to next rule.''
+    ;; We use @code{tail} below to go through all remaining rules so that any
+    ;; like LHS get absorbed before proceeding: This keeps LHS in sequence.
+    ;; Note: code-comm and lone-comm are added to terminals so that they end
+    ;; up in the match-table.  The parser will skip these if the automoton has
+    ;; no associated transitions for these.  This allows users to parse for
+    ;; comments in some rules but skip the rest.
+    (let iter ((tl '($error $end))     ; set of terminals
+              (head gram)   ; head of unprocessed productions
+              (rhs-l '())   ; list of RHSs being processed
+              (rhs #f))     ; RHS being processed
+      (cond
+       ((pair? rhs)
+       (case (caar rhs)
+         ((terminal)
+          (iter (add-el (cdar rhs) tl) head rhs-l (cdr rhs)))
+         (else
+          (iter tl head rhs-l (cdr rhs)))))
+       ((pair? rhs-l)
+       (iter tl head (cdr rhs-l) (car rhs-l)))
+       ((pair? head)
+       (iter tl (cdr head) (car head) rhs-l))
+       (else
+       (simple-format #t "need to process terminals\n")
+       (pretty-print pna)
+       tl)))
+    ))
+
+;; @end itemize
+;;; --- last line ---
index 4ae98f0b02261062dbdfc3ce154b6ffe4235472b..c2756e21448c2506ac3a567090daf980f44e4b37 100644 (file)
@@ -1,6 +1,10 @@
 BUGs and TODOs
 
-C99-009        <= next id
+C99-010        <= next id
+
+C99-009        18 Mar 2017, M.Wette
+       pprint generates two spaces in declarations e.g.,
+       int foo(int  x);
 
 C99-008        02 Mar 2017, M.Wette
        clean up error traps among raw-parser run-parse and parse-c99[x]
index e467d3975062e458203d38db599c979b31c084d1..468aba3a8b953db79c6042e60cb9f74ca6eefa82 100644 (file)
@@ -29,7 +29,7 @@
 
 (use-modules ((srfi srfi-9) #:select (define-record-type)))
 (use-modules ((sxml xpath) #:select (sxpath)))
-(use-modules (ice-9 regex))
+(use-modules (ice-9 pretty-print)) ;; for debugging
 
 (define-record-type cpi
   (make-cpi-1)
   (inc-defd cpi-idefd set-cpi-idefd!)  ; a-l of incfile => defines
   (ptl cpi-ptl set-cpi-ptl!)           ; parent typename list
   (ctl cpi-ctl set-cpi-ctl!)           ; current typename list
+  ;;(brlev cpi-brlev set-cpi-brlev!    ; curr brace level (#includes)
   )
 
 ;;.@deffn Procedure split-cppdef defstr => (<name> . <repl>)| \
-;;     ((<name>  <args> . <repl>)|#f
+;;     (<name>  <args> . <repl>)|#f
 ;; Convert define string to a dict item.  Examples:
 ;; @example
 ;; "ABC=123" => '("ABC" . "123")
 ;; "MAX(X,Y)=((X)>(Y)?(X):(Y))" => ("MAX" ("X" "Y") . "((X)>(Y)?(X):(Y))")
 ;; @end example
 ;; @end deffn
-(cond-expand
- (guile
-  (define split-cppdef
-    (let ((rx1 (make-regexp "^([A-Za-z0-9_]+)\\([^)]*\\)=(.*)$"))
-          (rx2 (make-regexp "^([A-Za-z0-9_]+)=(.*)$")))
-      (lambda (defstr)
-        (let* ((m1 (regexp-exec rx1 defstr))
-               (m2 (or m1 (regexp-exec rx2 defstr))))
-          (cond
-           ((regexp-exec rx1 defstr) =>
-            (lambda (m)
-              (let* ((s1 (match:substring m1 1))
-                     (s2 (match:substring m1 2))
-                     (s3 (match:substring m1 3)))
-                (cons s1 (cons s2 s3)))))
-           ((regexp-exec rx2 defstr) =>
-            (lambda (m)
-              (let* ((s1 (match:substring m2 1))
-                     (s2 (match:substring m2 2)))
-                (cons s1 s2))))
-           (else #f)))))))
- (mes
-  (define (split-cppdef s)
-    (apply cons (string-split s #\=)))))
+(define (split-cppdef defstr)
+  (let ((x2st (string-index defstr #\()) ; start of args
+       (x2nd (string-index defstr #\))) ; end of args
+       (x3 (string-index defstr #\=)))  ; start of replacement
+    (cond
+     ((not x3) #f)
+     ((and x2st x3)
+      ;;(if (not (eq? (1+ x2nd) x3)) (c99-err "bad CPP def: ~S" defstr))
+      (cons* (substring defstr 0 x2st)
+            (string-split
+             (string-delete #\space (substring defstr (1+ x2st) x2nd))
+             #\,)
+            (substring defstr (1+ x3))))
+     (else
+      (cons (substring defstr 0 x3) (substring defstr (1+ x3)))))))
+#|
+(use-modules (ice-9 regex))
+(define split-cppdef
+  (let ((rx1 (make-regexp "^([A-Za-z0-9_]+)\\(([^)]*)\\)=(.*)$"))
+       (rx2 (make-regexp "^([A-Za-z0-9_]+)=(.*)$")))
+    (lambda (defstr)
+      (let* ()
+       (cond
+        ((regexp-exec rx1 defstr) =>
+         (lambda (m1)
+           (let* ((s1 (match:substring m1 1))
+                  (s2 (match:substring m1 2))
+                  (s3 (match:substring m1 3)))
+             (cons* s1 (string-split s2 #\,) s3))))
+        ((regexp-exec rx2 defstr) =>
+         (lambda (m2)
+           (let* ((s1 (match:substring m2 1))
+                  (s2 (match:substring m2 2)))
+             (cons s1 s2))))
+        (else #f)))))))
+|#
 
 ;; @deffn Procedure make-cpi debug defines incdirs inchelp
 ;; @end deffn
     (set-cpi-incs! cpi incdirs)                ; list of include dir's
     (set-cpi-ptl! cpi '())             ; list of lists of typenames
     (set-cpi-ctl! cpi '())             ; list of typenames
-    ;; itynd idefd:
+    ;; Break up the helpers into typenames and defines.
     (let iter ((itynd '()) (idefd '()) (helpers inchelp))
       (cond ((null? helpers)
             (set-cpi-itynd! cpi itynd)
                 (lambda () (split-helper (car helpers)))
               (lambda (ityns idefs)
                 (iter (cons ityns itynd) (cons idefs idefd) (cdr helpers)))))))
+    ;; Assign builtins.
+    (and=> (assoc-ref (cpi-itynd cpi) "__builtin")
+          (lambda (tl) (set-cpi-ctl! cpi (append tl (cpi-ctl cpi)))))
+    (and=> (assoc-ref (cpi-idefd cpi) "__builtin")
+          (lambda (tl) (set-cpi-defs! cpi (append tl (cpi-defs cpi)))))
+    ;; Return the populated info.
     cpi))
 
 (define *info* (make-fluid #f))
 
 ;; ------------------------------------------------------------------------
 
-(define (p-err . args)
+(define (c99-err . args)
   (apply throw 'c99-error args))
 
 ;; @deffn {Procedure} read-cpp-line ch => #f | (cpp-xxxx)??
          (if (access? p R_OK) p (iter (cdr dirl)))))))
 
 (define (def-xdef? name mode)
-  (eqv? mode 'code))
+  (not (eqv? mode 'file)))
 
 ;; @deffn {Procedure} gen-c-lexer [#:mode mode] [#:xdef? proc] => procedure
 ;; Generate a context-sensitive lexer for the C99 language.  The generated
         (t-typename (assq-ref symtab 'typename))
         (xp1 (sxpath '(cpp-stmt define)))
         (xp2 (sxpath '(decl))))
-    ;; mode: 'code|'file
+    ;; mode: 'code|'file|'decl
     ;; xdef?: (proc name mode) => #t|#f  : do we expand #define?
     (lambda* (#:key (mode 'code) (xdef? #f))
       (let ((bol #t)                 ; begin-of-line condition
+           (xtxt #f)                 ; parsing cpp expanded text (kludge?)
            (ppxs (list 'keep))       ; CPP execution state stack
-           (info (fluid-ref *info*)) ; assume make and run in same thread
-           (x-def? (or xdef? def-xdef?)))
+           (info (fluid-ref *info*)) ; info shared w/ parser
+           (brlev 0)                 ; brace level
+           (x-def? (or xdef? def-xdef?))
+           )
        ;; Return the first (tval . lval) pair not excluded by the CPP.
        (lambda ()
 
-         (define (exec-cpp?) ; exec (vs pass to parser) CPP stmts?
-           (eqv? mode 'code))
-
-         (define (cpp-flow? keyw)
-           (memq keyw '(if elif else)))
-      
          (define (add-define tree)
            (let* ((tail (cdr tree))
                   (name (car (assq-ref tail 'name)))
          (define (apply-helper file)
            (let* ((tyns (assoc-ref (cpi-itynd info) file))
                   (defs (assoc-ref (cpi-idefd info) file)))
+             ;;(simple-format #t "apply-helper ~S => ~S\n" file tyns)   
+             ;;(simple-format #t "  itynd= ~S\n" (cpi-itynd info))
              (when tyns
                (for-each add-typename tyns)
                (set-cpi-defs! info (append defs (cpi-defs info))))
              tyns))
          
-         ;; Evaluate expression text in #if of #elif statement.
-         (define (eval-cpp-cond-text text)
-           (with-throw-handler
-            'cpp-error
-            (lambda ()
-              (let* ((defs (cpi-defs info))
-                     (rhs (cpp-expand-text text defs))
-                     (exp (parse-cpp-expr rhs)))
-                (eval-cpp-expr exp defs)))
-            (lambda (key fmt . args)
-              (report-error fmt args)
-              (throw 'c99-error "CPP error"))))
-
          (define (inc-stmt->file stmt)
            (let* ((arg (cadr stmt)) (len (string-length arg)))
              (substring arg 1 (1- len))))
          (define (inc-file->path file)
            (find-file-in-dirl file (cpi-incs info)))
 
-         (define (eval-cpp-stmt-1/code stmt)
-           ;; eval control flow states: {skip-look, keep, skip-done, skip}
-           (case (car stmt)
-             ((if)
-              (case (car ppxs)
-                ((skip-look skip-done skip) ;; don't eval if excluded
-                 (set! ppxs (cons 'skip ppxs)))
-                (else
-                 (let ((val (eval-cpp-cond-text (cadr stmt))))
-                   (if (not val) (p-err "unresolved: ~S" (cadr stmt)))
-                   (if (eq? 'keep (car ppxs))
-                       (if (zero? val)
-                           (set! ppxs (cons 'skip-look ppxs))
-                           (set! ppxs (cons 'keep ppxs)))
-                       (set! ppxs (cons 'skip-done ppxs)))))))
-             ((elif)
-              (case (car ppxs)
-                ((skip) #t) ;; don't eval if excluded
-                (else
-                 (let ((val (eval-cpp-cond-text (cadr stmt))))
-                   (if (not val) (p-err "unresolved: ~S" (cadr stmt)))
-                   (case (car ppxs)
-                     ((skip-look) (if (not (zero? val)) (set-car! ppxs 'keep)))
-                     ((keep) (set-car! ppxs 'skip-done)))))))
-             ((else)
-              (case (car ppxs)
-                ((skip-look) (set-car! ppxs 'keep))
-                ((keep) (set-car! ppxs 'skip-done))))
-             ((endif)
-              (set! ppxs (cdr ppxs)))
+         (define (code-if stmt)
+           ;;(simple-format #t "code-if: ppxs=~S\n" ppxs)
+           (case (car ppxs)
+             ((skip-look skip-done skip) ;; don't eval if excluded
+              ;;(simple-format #t "code-if: SKIP\n")
+              (set! ppxs (cons 'skip ppxs)))
              (else
-              (if (eqv? 'keep (car ppxs))
-                  (eval-cpp-stmt-2/code stmt)))))
+              ;;(simple-format #t "code-if: KEEP\n")
+              ;;(simple-format #t "  text=~S\n" (cadr stmt))
+              ;;(simple-format #t "  defs=~S\n" (cpi-defs info))
+              (let* ((defs (cpi-defs info))
+                     (val (eval-cpp-cond-text (cadr stmt) defs)))
+                (if (not val) (c99-err "unresolved: ~S" (cadr stmt)))
+                (if (eq? 'keep (car ppxs))
+                    (if (zero? val)
+                        (set! ppxs (cons 'skip-look ppxs))
+                        (set! ppxs (cons 'keep ppxs)))
+                    (set! ppxs (cons 'skip-done ppxs))))))
+           stmt)
+
+         (define (code-elif stmt)
+           (case (car ppxs)
+             ((skip) #t) ;; don't eval if excluded
+             (else
+              (let* ((defs (cpi-defs info))
+                     (val (eval-cpp-cond-text (cadr stmt) defs)))
+                (if (not val) (c99-err "unresolved: ~S" (cadr stmt)))
+                (case (car ppxs)
+                  ((skip-look) (if (not (zero? val)) (set-car! ppxs 'keep)))
+                  ((keep) (set-car! ppxs 'skip-done))))))
+           stmt)
+
+         (define (code-else stmt)
+           (case (car ppxs)
+             ((skip-look) (set-car! ppxs 'keep))
+             ((keep) (set-car! ppxs 'skip-done)))
+           stmt)
 
-         (define (eval-cpp-stmt-2/code stmt)
-           ;; eval non-control flow
+         (define (code-endif stmt)
+           (set! ppxs (cdr ppxs))
+           stmt)
+         
+         (define (eval-cpp-incl/here stmt) ;; => stmt
+           ;; include file inplace
+           (let* ((file (inc-stmt->file stmt))
+                  (path (inc-file->path file)))
+             (cond
+              ((apply-helper file))
+              ((not path) (c99-err "not found: ~S" file)) ; file not found
+              (else (set! bol #t) (push-input (open-input-file path))))
+             stmt))
+
+         (define (eval-cpp-incl/tree stmt) ;; => stmt
+           ;; include file as a new tree
+           (let* ((file (inc-stmt->file stmt))
+                  (path (inc-file->path file)))
+             (cond
+              ((apply-helper file) stmt)                ; use helper
+              ((not path) (c99-err "not found: ~S" file)) ; file not found
+              ((with-input-from-file path run-parse) => ; add tree to stmt
+               (lambda (tree)
+                 ;;(pretty-print tree (current-error-port))
+                 ;;(pretty-print (xp1 tree))
+                 (for-each add-define (xp1 tree))
+                 (append stmt tree))))))
+
+         (define (eval-cpp-stmt/code stmt) ;; => stmt
            (case (car stmt)
-             ;; actions
-             ((include)
-              (let* ((file (inc-stmt->file stmt))
-                     (path (inc-file->path file)))
-                (cond
-                 ((apply-helper file)) ; use helper
-                 ((not path) (p-err "not found: ~S" file)) ; file not found
-                 (else (set! bol #t) (push-input (open-input-file path))))))
-             ((define) (add-define stmt))
-             ((undef) (rem-define (cadr stmt)))
-             ((error) (p-err "error: #error ~A" (cadr stmt)))
-             ((pragma) #t) ;; ignore for now
-             (else (error "bad cpp flow stmt"))))
-
-         (define (eval-cpp-stmt-1/file stmt)
+             ((if) (code-if stmt))
+             ((elif) (code-elif stmt))
+             ((else) (code-else stmt))
+             ((endif) (code-endif stmt))
+             (else
+              (if (eqv? 'keep (car ppxs))
+                  (case (car stmt)
+                    ((include) (eval-cpp-incl/here stmt))
+                    ((define) (add-define stmt) stmt)
+                    ((undef) (rem-define (cadr stmt)) stmt)
+                    ((error) (c99-err "error: #error ~A" (cadr stmt)))
+                    ((pragma) stmt) ;; ignore for now
+                    (else (error "bad cpp flow stmt")))))))
+              
+         (define (eval-cpp-stmt/decl stmt) ;; => stmt
            (case (car stmt)
-             ((if) (cpi-push))
-             ((elif else) (cpi-shift))
-             ((endif) (cpi-pop))
-             (else (eval-cpp-stmt-2/file stmt))))
-           
-         (define (eval-cpp-stmt-2/file stmt)
-           ;; eval non-control flow
+             ((if) (code-if stmt))
+             ((elif) (code-elif stmt))
+             ((else) (code-else stmt))
+             ((endif) (code-endif stmt))
+             (else
+              (if (eqv? 'keep (car ppxs))
+                  (case (car stmt)
+                    ((include)         ; use tree unless inside braces
+                     (if (zero? brlev)
+                         (eval-cpp-incl/tree stmt)
+                         (eval-cpp-incl/here stmt)))
+                    ((define) (add-define stmt) stmt)
+                    ((undef) (rem-define (cadr stmt)) stmt)
+                    ((error) (c99-err "error: #error ~A" (cadr stmt)))
+                    ((pragma) stmt) ;; ignore for now
+                    (else (error "bad cpp flow stmt")))
+                  stmt))))
+              
+         (define (eval-cpp-stmt/file stmt) ;; => stmt
            (case (car stmt)
-             ;; includes
-             ((include)
-              (let* ((file (inc-stmt->file stmt))
-                     (path (inc-file->path file)))
-                (cond
-                 ((apply-helper file)) ; use helper
-                 ((not path) (p-err "not found: ~S" file)) ; file not found
-                 ((with-input-from-file path c99-parser-run-parse) => ; include tree
-                  (lambda (tree) (for-each add-define (xp1 tree))))
-                 (else (p-err "included from ~S" path)))))
-             ((define) (add-define stmt))
-             ((undef) (rem-define (cadr stmt)))
-             ((error) #f)
-             ((pragma) #t) ;; need to work this
+             ((if) (cpi-push) stmt)
+             ((elif else) (cpi-shift) stmt)
+             ((endif) (cpi-pop) stmt)
+             ((include) (eval-cpp-incl/tree stmt))
+             ((define) (add-define stmt) stmt)
+             ((undef) (rem-define (cadr stmt)) stmt)
+             ((error) stmt)
+             ((pragma) stmt) ;; need to work this
              (else (error "bad cpp flow stmt"))))
-           
+
+         ;; Maybe evaluate the CPP statement.
          (define (eval-cpp-stmt stmt)
            (with-throw-handler
             'cpp-error
             (lambda ()
               (case mode
-                ((code) (eval-cpp-stmt-1/code stmt))
-                ((file) (eval-cpp-stmt-1/file stmt))))
+                ((code) (eval-cpp-stmt/code stmt))
+                ((decl) (eval-cpp-stmt/decl stmt))
+                ((file) (eval-cpp-stmt/file stmt))
+                (else (error "lang/c99 coding error"))))
             (lambda (key fmt . rest)
               (report-error fmt rest)
               (throw 'c99-error "CPP error"))))
 
+         ;; Predicate to determine if we pass the cpp-stmt to the parser.
+         ;; @itemize
+         ;; If code mode, never
+         ;; If file mode, all except includes between { }
+         ;; If decl mode, only defines and includes outside {}
+         ;; @end itemize
+         (define (pass-cpp-stmt? stmt)
+           (case mode
+             ((code) #f)
+             ((decl) (and (zero? brlev) (memq (car stmt) '(include define))))
+             ((file) (or (zero? brlev) (not (eqv? (car stmt) 'include))))
+             (else (error "lang/c99 coding error"))))
+
          ;; Composition of @code{read-cpp-line} and @code{eval-cpp-line}.
          (define (read-cpp-stmt ch)
            (and=> (read-cpp-line ch) cpp-line->stmt))
            (let iter ((ch (read-char)))
              (cond
               ((eof-object? ch)
+               (set! xtxt #f)
                (if (pop-input) (iter (read-char)) (assc-$ '($end . ""))))
               ((eq? ch #\newline) (set! bol #t) (iter (read-char)))
               ((char-set-contains? c:ws ch) (iter (read-char)))
                 ((read-comm ch #t) => assc-$)
                 ((read-cpp-stmt ch) =>
                  (lambda (stmt)
-                   (eval-cpp-stmt stmt)
-                   (case mode
-                     ((code) (iter (read-char)))
-                     ((file) (assc-$ `(cpp-stmt . ,stmt))))))
+                   (let ((stmt (eval-cpp-stmt stmt))) ; eval can add tree
+                     (if (pass-cpp-stmt? stmt)
+                         (assc-$ `(cpp-stmt . ,stmt))
+                         (iter (read-char))))))
                 (else (iter ch))))
               ((read-ident ch) =>
                (lambda (name)
                  (let ((symb (string->symbol name)))
+                   ;;(simple-format #t "id: name=~S xtxt=~S\n" name xtxt)
                    (cond
-                    ((and (x-def? name mode)
+                    ((and (not xtxt)
+                          (if (procedure? x-def?) (x-def? name mode) x-def?)
                           (expand-cpp-macro-ref name (cpi-defs info)))
                      => (lambda (st)
+                          ;;(simple-format #t "repl=~S\n" st)
+                          (set! xtxt #t) ; so we don't re-expand
                           (push-input (open-input-string st))
                           (iter (read-char))))
                     ((assq-ref keytab symb)
               ((read-c-string ch) => assc-$)
               ((read-c-chlit ch) => assc-$)
               ((read-comm ch #f) => assc-$)
+              ((and (char=? ch #\{) (set! brlev (1+ brlev)) #f) #f)
+              ((and (char=? ch #\}) (set! brlev (1- brlev)) #f) #f)
               ((read-chseq ch) => identity)
               ((assq-ref chrtab ch) => (lambda (t) (cons t (string ch))))
               ((eqv? ch #\\) ;; C allows \ at end of line to continue
index 0de592bafd93e59c47f633e5afeebdcfcc660fbd..2c975856788557e7343543686622a7b3c10be580 100644 (file)
 ;;; You should have received a copy of the GNU General Public License
 ;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-;; C preprocessor.  This is not complete.
+;; C preprocessor macro expansion and condition text parse-and-eval
+;; ref: https://gcc.gnu.org/onlinedocs/gcc-3.0.1/cpp_3.html
 
 (define-module (nyacc lang c99 cpp)
-  #:export (parse-cpp-stmt
+  #:export (
            cpp-line->stmt
-           parse-cpp-expr
-           eval-cpp-expr
-           cpp-expand-text
-           expand-cpp-macro-ref
-           )
+           eval-cpp-cond-text
+           expand-cpp-macro-ref)
   #:use-module (nyacc parse)
   #:use-module (nyacc lex)
   #:use-module (nyacc lang util)
   #:use-module (rnrs arithmetic bitwise)
+  #:use-module (ice-9 match)
   #:use-module (system base pmatch)
   )
 
-(cond-expand
- (guile-2)
- (guile
-  (use-modules (ice-9 syncase)))
- (mes))
-
 (define c99-std-defs
   '("__DATE__" "__FILE__" "__LINE__" "__STDC__" "__STDC_HOSTED__"
     "__STDC_VERSION__" "__TIME__"))
   (cond
    ((string=? str "__DATE__") "M01 01 2001")
    ((string=? str "__FILE__") "(unknown)")
-   ((string=? str "__LINE__") 0)
-   ((string=? str "__STDC__") 1)
-   ((string=? str "__STDC_HOSTED__") 0)
-   ((string=? "__STDC_VERSION__") 201701)
-   ((string=? "__TIME__") "00:00:00")
+   ((string=? str "__LINE__") "0")
+   ((string=? str "__STDC__") "1")
+   ((string=? str "__STDC_HOSTED__") "0")
+   ((string=? str "__STDC_VERSION__") "201701")
+   ((string=? str "__TIME__") "00:00:00")
    (else #f)))
 
-;; @deffn read-ellipsis ch
+(define inline-whitespace (list->char-set '(#\space #\tab)))
+  
+;;.@deffn {Procedure} skip-il-ws ch
+;; Skip in-line whitespace
+;; @end deffn
+(define (skip-il-ws ch)
+  (cond
+   ((eof-object? ch) ch)
+   ((char-set-contains? inline-whitespace ch) (skip-il-ws (read-char)))
+   (else ch)))
+
+;; @deffn {Procedure} read-ellipsis ch
 ;; read ellipsis
+;; @end deffn
 (define (read-ellipsis ch)
   (cond
    ((eof-object? ch) #f)
    ((char=? ch #\.) (read-char) (read-char) "...") ; assumes correct syntax
    (else #f)))
 
-;; @deffn cpp-define => (define (name "ADD") (args "X" "Y") (repl "X+Y"))
-;; output is like
-;; @code{(name "ABC") (repl "123")} or
-;; @code{(name "ABC") (args "X" "Y") (repl "X+Y")}
+;; @deffn {Procedure} cpp-define
+;; Reads CPP define from current input and generates a cooresponding sxml
+;; expression.
+;; @example
+;;   (define (name "ABC") (repl "123"))
+;; OR
+;;   (define (name "ABC") (args "X" "Y") (repl "X+Y"))
+;; @example
+;; @end deffn
 (define (cpp-define)
 
   (define (p-args la) ;; parse args
        `(define (name ,name) (repl ,repl)))))
        
 
-;; @deffn cpp-include
+;; @deffn {Procedure} cpp-include
 ;; Parse CPP include statement.
 (define (cpp-include)
   (let* ((beg-ch (skip-il-ws (read-char)))
                     (iter (cons ch cl) (read-char))))))
     `(include ,path)))
 
-;; @deffn cpp-line->stmt line defs => (stmt-type text)
+;; @deffn {Procedure} cpp-line->stmt line defs => (stmt-type text)
 ;; Parse a line from a CPP statement and return a parse tree.
 ;; @example
 ;; (parse-cpp-stmt "define X 123") => (define "X" "123")
 ;; @end example
 ;; To evaluate the @code{if} statements use @code{parse-cpp-expr} and
 ;; @code{eval-cpp-expr}.
+;; @end deffn
 (define (cpp-line->stmt line)
   (define (rd-ident) (read-c-ident (skip-il-ws (read-char))))
   (define (rd-num) (and=> (read-c-num (skip-il-ws (read-char))) cdr))
 (include-from-path "nyacc/lang/c99/mach.d/cpptab.scm")
 (include-from-path "nyacc/lang/c99/mach.d/cppact.scm")
 
-(define cpp-raw-parser
+(define raw-parser
   (make-lalr-parser
    (list (cons 'len-v cpp-len-v) (cons 'pat-v cpp-pat-v) (cons 'rto-v cpp-rto-v)
         (cons 'mtab cpp-mtab) (cons 'act-v cpp-act-v))))
 (define (cpp-err fmt . args)
   (apply throw 'cpp-error fmt args))
 
-;;.@deffn skip-il-ws ch
-;; Skip in-line whitespace
-(define skip-il-ws
-  (let ((il-ws (list->char-set '(#\space #\tab))))
-    (lambda (ch)
-      (cond
-       ((eof-object? ch) ch)
-       ((char-set-contains? il-ws ch) (skip-il-ws (read-char)))
-       (else ch)))))
-
 ;; Since we want to be able to get CPP statements with comment in tact
 ;; (e.g., for passing to @code{pretty-print-c99}) we need to remove
 ;; comments when parsing CPP expressions.  We convert a comm-reader
 (define gen-cpp-lexer
   (make-lexer-generator cpp-mtab #:comm-skipper cpp-comm-skipper))
 
-;; @deffn parse-cpp-expr text => tree
+;; @deffn {Procedure} parse-cpp-expr text => tree
 ;; Given a string returns a cpp parse tree.  This is called by
 ;; @code{eval-cpp-expr}.  The text will have had all CPP defined symbols
 ;; expanded already so no identifiers should appear in the text.
 ;; A @code{cpp-error} will be thrown if a parse error occurs.
+;; @end deffn
 (define (parse-cpp-expr text)
   (with-throw-handler
    'nyacc-error
    (lambda ()
      (with-input-from-string text
-       (lambda () (cpp-raw-parser (gen-cpp-lexer)))))
+       (lambda () (raw-parser (gen-cpp-lexer)))))
    (lambda (key fmt . args)
      (apply throw 'cpp-error fmt args))))
 
-;; @deffn eval-cpp-expr tree dict => datum
+;; @deffn {Procedure} eval-cpp-expr tree dict => datum
 ;; Evaluate a tree produced from @code{parse-cpp-expr}.
 ;; The tree passed to this routine is 
+;; @end deffn
 (define (eval-cpp-expr tree dict)
   (letrec
       ((tx (lambda (tr ix) (list-ref tr ix)))
            (else (error "incomplete implementation"))))))
     (eval-expr tree)))
 
-;; Note: scan-cpp-input scans replacement text.  When identifiers are found
-;; they are tested for expansion as follows:
-;; @enumerate
-;; @item If already expanded, then ignore.
-;; @item If followed by @code{(}, then use @code{collect-args} to get the
-;; arguments and ...
-;; @item Otherwise insert the replacement text and continue scanning (at
-;; first character of new replacement text.
-;; @end enumerate
-
-;; @deffn rtokl->string tokl => string
+;;.@deffn {Procedure} rtokl->string reverse-token-list => string
 ;; Convert reverse token-list to string.
+;; @end deffn
 (define (rtokl->string tokl)
 
   ;; Turn reverse chl into a string and insert it into the string list stl.
   (define (add-chl chl stl)
     (if (null? chl) stl (cons (list->string chl) stl)))
 
-  ;; Works like this: Scan through the list of tokens (key-val pairs or lone
-  ;; characters).  Lone characters are collected in a list (@code{chl}); pairs
-  ;; are converted into strings and combined with list of characters into a
-  ;; list of strings.  When done the list of strings is combined to one string.
-  (let iter ((stl '()) (chl '()) (nxt #f) (tkl tokl))
+  ;;(simple-format #t "\nused=~S\n" used)
+  ;; Works like this: Scan through the list of tokens (key-val pairs or
+  ;; lone characters).  Lone characters are collected in a list (@code{chl});
+  ;; pairs are converted into strings and combined with list of characters
+  ;; into a list of strings.  When done the list of strings is combined to
+  ;; one string.  (The token 'argval is expansion of argument.)
+  (let iter ((stl '())            ; list of strings to reverse-append
+            (chl '())             ; char list
+            (nxt #f)              ; next string to add after chl
+            (tkl tokl))           ; input token list
     (cond
-     (nxt (iter (cons nxt (add-chl chl stl)) '() #f tkl))
-     ((null? tkl) (apply string-append (add-chl chl stl)))
-     ((char? (car tkl)) (iter stl (cons (car tkl) chl) nxt (cdr tkl)))
+     (nxt
+      (iter (cons nxt (add-chl chl stl)) '() #f tkl))
+     ((null? tkl)
+      (apply string-append (add-chl chl stl)))
+     ((char? (car tkl))
+      (iter stl (cons (car tkl) chl) nxt (cdr tkl)))
      (else
       (pmatch tkl
-       (((arg . ,arg) dhash (,key . ,val) . ,rest)
-        (iter stl chl nxt
-              (acons key (string-append val arg) (list-tail tkl 3))))
-
-       (((,key . ,val) dhash (arg . ,arg) . ,rest)
+       (((ident . ,rval) dhash (ident . ,lval) . ,rest)
         (iter stl chl nxt
-              (acons 'arg (string-append arg val) (list-tail tkl 3))))
-
-       (((arg . ,arg) hash . ,rest)
+              (acons 'ident (string-append lval rval) (list-tail tkl 3))))
+       (((ident . ,arg) hash . ,rest)
         (iter stl chl (string-append "\"" arg "\"") (list-tail tkl 2)))
-
-       (((comm . ,val) . ,rest)
-        (iter stl chl (string-append "/*" val " */") (cdr tkl)))
-
-       (((ident . ,rval) (ident . ,lval) . ,rest)
-        (iter stl chl (string-append " " rval) (cdr tkl)))
-
+       (((ident . ,iden) (ident . ,lval) . ,rest)
+        (iter stl chl iden rest))
+       (((ident . ,iden) . ,rest)
+        (iter stl chl iden rest))
        (((string . ,val) . ,rest)
         (iter stl (cons #\" chl) val (cons #\" rest)))
-
-       (((ident . ,val) . ,rest)
-        (iter stl chl val rest))
-
-       (((arg . ,val) . ,rest)
-        (iter stl chl val rest))
-
        (((defined . ,val) . ,rest)
         (iter stl chl val rest))
-
+       ((space space . ,rest)
+        (iter stl chl nxt rest))
        ((space . ,rest)
         (iter stl (cons #\space chl) nxt rest))
-
        ((,asis . ,rest)
         (iter stl chl asis rest))
-
-       (otherwise
+       (,otherwise
         (error "no match" tkl)))))))
 
-;; @deffn scan-cpp-input argd used dict end-tok => string
-;; Process replacement text from the input port and generate a (reversed)
-;; token-list.  If end-tok, stop at, and push back, @code{,} or @code{)}.
-;; If end-tok is @code{,} then read until @code{,} or @code{(}.
-;; The argument @var{argd} is a dictionary (argument name, argument
-;; value) pairs which will be expanded as needed.  This routine is called
-;; by collect-args, expand-cpp-repl and cpp-expand-text.
-(define (scan-cpp-input argd dict used end-tok)
+;; We just scanned "defined", now need to scan the arg to inhibit expansion.
+;; For example, we have scanned "defined"; we now scan "(FOO)" or "FOO", and
+;; return "defined(FOO)" or "defined FOO".
+(define (scan-defined-arg)
+  (let* ((ch (skip-il-ws (read-char))) (no-ec (not (char=? ch #\())))
+    (let iter ((chl (list ch)) (ch (skip-il-ws (read-char))))
+      (cond
+       ((eof-object? ch)
+       (if no-ec
+           (string-append "defined " (list->string (reverse chl)))
+           (cpp-err "illegal argument to `defined'")))
+       ((char-set-contains? c:ir ch)
+       (iter (cons ch chl) (read-char)))
+       (no-ec
+       (unread-char ch)
+       (string-append "defined " (list->string (reverse chl))))
+       ((char=? #\) (skip-il-ws ch))
+       (string-append "defined" (list->string (reverse (cons #\) chl)))))
+       (else
+       (cpp-err "illegal argument to  `defined'"))))))
+
+(define (scan-cpp-input defs used end-tok)
   ;; Works like this: scan for tokens (comments, parens, strings, char's, etc).
   ;; Tokens are collected in a (reverse ordered) list (tkl) and merged together
-  ;; to a string on return using @code{rtokl->string}.
-
-  ;; We just scanned "defined", now need to scan the arg to inhibit expansion.
-  ;; For example, we have scanned "defined"; we now scan "(FOO)" or "FOO", and
-  ;; return "defined(FOO)" or "defined FOO".
-  (define (scan-defined-arg)
-    (let* ((ch (skip-il-ws (read-char))) (no-ec (not (char=? ch #\())))
-      (let iter ((chl (list ch)) (ch (skip-il-ws (read-char))))
+  ;; to a string on return using @code{rtokl->string}.  Keep track of expanded
+  ;; identifiers and rerun if something got expanded.  Also, keep track of
+  ;; ## and spaces so that we can parse ID /* foo */ ## /* bar */ 123
+  ;; as well as ABC/*foo*/(123,456).
+
+  (define (trim-spaces tkl)
+      (if (and (pair? tkl) (eqv? 'space (car tkl)))
+         (trim-spaces (cdr tkl))
+         tkl))
+
+  (define (finish rr tkl)
+    (let* ((tkl (if end-tok (trim-spaces tkl) tkl))
+          (repl (rtokl->string tkl)))
+      ;;(if (null? rr) (simple-format #t "finish ~S\n" tkl))
+      (if (pair? rr)
+         (expand-cpp-repl repl defs (append rr used)) ;; re-run
+         repl)))
+     
+  ;;(simple-format #t "scan-cpp-input end-tok=~S\n" end-tok)
+  (let iter ((rr '())                  ; list symbols resolved
+            (tkl '())                  ; token list of
+            (lv 0)                     ; level
+            (ch (skip-il-ws (read-char)))) ; next character
+    ;;(unless end-tok (simple-format #t "tkl=~S ch=~S\n" tkl ch))
+    (cond
+     ((eof-object? ch) (finish rr tkl))
+     ((and (eqv? end-tok ch) (zero? lv))
+      (unread-char ch) (finish rr tkl))
+     ((and end-tok (char=? #\) ch) (zero? lv))
+      (unread-char ch) (finish rr tkl))
+     ((or (char-set-contains? c:ws ch) ; whitespace
+         (read-c-comm ch #f))          ; comment
+      (iter rr (cons 'space tkl) lv (skip-il-ws (read-char))))
+     ((read-c-ident ch) =>
+      (lambda (iden)
+       (if (equal? iden "defined")
+           (iter rr (acons 'defined (scan-defined-arg) tkl) lv (read-char))
+           (let ((rval (expand-cpp-macro-ref iden defs used)))
+             (if rval
+                 (iter #t (cons rval tkl) lv (read-char))
+                 (iter rr (acons 'ident iden tkl) lv (read-char)))))))
+     ((read-c-string ch) =>
+      (lambda (st) (iter rr (acons 'string (cdr st) tkl) lv (read-char))))
+     ((char=? #\( ch) (iter rr (cons ch tkl) (1+ lv) (read-char)))
+     ((char=? #\) ch) (iter rr (cons ch tkl) (1- lv) (read-char)))
+     (else
+      (iter rr (cons ch tkl) lv (read-char))))))
+
+;; @deffn {Procedure} collect-args arglargd defs used => argd
+;; Collect arguments to a macro which appears in C code.  If not looking at
+;; @code{(} return @code{#f}, else scan and eat up to closing @code{)}.
+;; If multiple whitespace characters are skipped at the front then only
+;; one @code{#\space} is re-inserted.
+;; @end deffn
+(define (collect-args argl defs used)
+  (let iter1 ((sp #f) (ch (read-char)))
+    (cond
+     ((eof-object? ch) (if sp (unread-char #\space)) #f)
+     ((char-set-contains? inline-whitespace ch) (iter1 #t (read-char)))
+     ((char=? #\( ch)
+      (let iter2 ((argl argl) (argv '()) (ch ch))
        (cond
-        ((eof-object? ch)
-         (if no-ec
-             (string-append "defined " (list->string (reverse chl)))
-             (cpp-err "illegal argument to `defined'")))
-        ((char-set-contains? c:ir ch)
-         (iter (cons ch chl) (read-char)))
-        (no-ec
-         (unread-char ch)
-         (string-append "defined " (list->string (reverse chl))))
-        ((char=? #\) (skip-il-ws ch))
-         (string-append "defined" (list->string (reverse (cons #\) chl)))))
+        ((eqv? ch #\)) (reverse argv))
+        ((null? argl) (cpp-err "arg count"))
+        ((and (null? (cdr argl)) (string=? (car argl) "..."))
+         (let ((val (scan-cpp-input defs used #\))))
+           (iter2 (cdr argl) (acons "__VA_ARGS__" val argv) (read-char))))
+        ((or (char=? ch #\() (char=? ch #\,))
+         (let* ((val (scan-cpp-input defs used #\,)))
+           (iter2 (cdr argl) (acons (car argl) val argv) (read-char))))
         (else
-         (cpp-err "illegal argument to  `defined'"))))))
-
-  ;; token list is list of
-  ;; 1) characters as char
-  ;; 2) identifiers as string
-  ;; 3) strings as '(string . <string>)
-  ;; 4) 'hash 'dhash
-  (let iter ((tkl '())         ; token list of 
-            (lvl 0)            ; level
-            (ch (read-char)))  ; next character
+         (error "cpp.scm, collect-args: coding error")))))
+     (else (if sp (unread-char #\space)) #f))))
+
+;; @deffn {Procedure} px-cpp-ftn-repl argd repl => string
+;; pre-expand CPP function where @var{argd} is an a-list of arg name
+;; and replacement and repl is the defined replacement
+;; 
+;; argd is alist of arguments and token lists
+;; if end-tok == #f ignore levels
+;; ident space fixed float chseq hash dhash arg
+;; need to decide if we should use `(space ,tkl) or `((space) ,tkl)
+;; This should replace args and execute hash and double-hash ??
+;; @end deffn
+(define (px-cpp-ftn argd repl)
+  (with-input-from-string repl
+    (lambda ()
+      ;;(simple-format #t "px-cpp-ftn argd=~S repl=~S\n" argd repl)
+      (px-cpp-ftn-1 argd))))
+
+(define (px-cpp-ftn-1 argd)
+
+  ;; Turn reverse chl into a string and insert it into the token stream.
+  (define (ins-chl chl stl)
+    (if (null? chl) stl (cons (list->string (reverse chl)) stl)))
+
+  (define (rem-space chl)
+    (let iter ((chl chl))
+      (cond
+       ((null? chl) chl)
+       ((char-set-contains? c:ws (car chl)) (iter (cdr chl)))
+       (else chl))))
+
+  (define (mk-string str) (string-append "\"" str "\""))
+
+  (let iter ((stl '())                 ; string list
+            (chl '())                  ; character list
+            (nxt #f)                   ; next string after char list
+            (ch (read-char)))          ; next character
+    ;;(simple-format #t "px-1: stl=~S chl=~S nxt=~S ch=~S\n" stl chl nxt ch)
     (cond
-     ;; have item to add, but first add in char's
-     ;;(nxt (iter (cons nxt (add-chl chl tkl)) '() #f lvl ch))
-     ;; If end of string or see end-ch at level 0, then return.
-     ((eof-object? ch) (rtokl->string tkl))
-     
-     ((and (eqv? end-tok ch) (zero? lvl))
-      (unread-char ch) (rtokl->string tkl))
-     ((and end-tok (char=? #\) ch) (zero? lvl))
-      (unread-char ch) (rtokl->string tkl))
-     
-     ((read-c-comm ch #f) =>
-      (lambda (cp) (iter (acons `comm (cdr cp) tkl) lvl (read-char))))
-     
+     (nxt (iter (cons nxt (ins-chl chl stl)) '() #f ch))
+     ((eof-object? ch)
+      (apply string-append (reverse (ins-chl chl stl))))
      ((char-set-contains? c:ws ch)
-      (if (and (pair? tkl) (char? (car tkl)))
-         (iter (cons 'space tkl) lvl (read-char))
-         (iter tkl lvl (read-char))))
-     
-     ((char=? #\( ch) (iter (cons ch tkl) (1+ lvl) (read-char)))
-     ((char=? #\) ch) (iter (cons ch tkl) (1- lvl) (read-char)))
+      (iter stl (cons #\space chl) nxt (skip-il-ws (read-char))))
+     ((read-c-comm ch #f) (iter stl (cons #\space chl) nxt (read-char)))
+     ((read-c-string ch) =>
+      (lambda (st) (iter stl chl (mk-string (cdr st)) (read-char))))
+     ((char=? #\( ch) (iter stl (cons ch chl) nxt (read-char)))
+     ((char=? #\) ch) (iter stl (cons ch chl) nxt (read-char)))
+     ((read-c-ident ch) =>             ; replace if aval
+      (lambda (iden)
+       (iter stl chl (or (assoc-ref argd iden) iden) (read-char))))
      ((char=? #\# ch)
       (let ((ch (read-char)))
        (if (eqv? ch #\#)
-           (iter (cons 'dhash tkl) lvl (read-char))
-           (iter (cons 'hash tkl) lvl ch))))
-     ((read-c-string ch) =>
-      (lambda (st) (iter (acons 'string (cdr st) tkl) lvl (read-char))))
-     ((read-c-ident ch) =>
-      (lambda (iden)
-       (if (equal? iden "defined")
-           ;; "defined" is a special case
-           (let ((arg (scan-defined-arg)))
-             (iter (acons 'defined arg tkl) lvl (read-char)))
-           ;; otherwise ...
-           (let* ((aval (assoc-ref argd iden))  ; lookup argument
-                  (rval (assoc-ref dict iden))) ; lookup macro def
-             (cond
-              ((member iden used)      ; name used
-               (iter (cons iden tkl) lvl (read-char)))
-              (aval                    ; arg ref
-               (iter (acons 'arg aval tkl) lvl (read-char)))
-              ((string? rval)          ; cpp repl
-               (iter (cons rval tkl) lvl (read-char)))
-              ((pair? rval)            ; cpp macro
-               (let* ((argl (car rval)) (text (cdr rval))
-                      (argd (collect-args argl argd dict used))
-                      (newl (expand-cpp-repl text argd dict (cons iden used))))
-                 (iter (cons newl tkl) lvl (read-char))))
-              (else                    ; normal identifier
-               (iter (acons 'ident iden tkl) lvl (read-char))))))))
-     (else
-      (iter (cons ch tkl) lvl (read-char))))))
+           (iter stl (rem-space chl) nxt (skip-il-ws (read-char)))
+           (let* ((aref (read-c-ident (skip-il-ws ch)))
+                  (aval (assoc-ref argd aref)))
+             (if (not aref) (cpp-err "expecting arg-ref"))
+             (if (not aval) (cpp-err "expecting arg-val"))
+             (iter stl chl (mk-string aval) (read-char))))))
+     (else (iter stl (cons ch chl) nxt (read-char))))))
+  
+;; @deffn {Procedure} cpp-expand-text text defs [used] => string
+;; Expand the string @var{text} using the provided CPP @var{defs} a-list.
+;; Identifiers in the list of strings @var{used} will not be expanded.
+;; @end deffn
+(define* (cpp-expand-text text defs #:optional (used '()))
+  ;;(simple-format #t "cpp-expand-text ~S\n" text)
+  (with-input-from-string text
+    (lambda () (scan-cpp-input defs used #f))))
 
-;; @deffn collect-args argl argd dict used => argd
-;; to be documented
-;; I think argd is a passthrough for scan-cpp-input
-;; argl: list of formal arguments in #define
-;; argd: used? (maybe just a pass-through for scan-cpp-input
-;; dict: dict of macro defs
-;; used: list of already expanded macros
-;; TODO clean this up
-;; should be looking at #\( and eat up to matching #\)
-(define (collect-args argl argd dict used)
-  (let iter ((argl argl) (argv '()) (ch (skip-il-ws (read-char))))
-    ;; ch should always be #\(, #\, or #\)
-    (cond
-     ((eqv? ch #\)) (reverse argv))
-     ((null? argl) (cpp-err "arg count"))
-     ((and (null? (cdr argl)) (string=? (car argl) "..."))
-      (let ((val (scan-cpp-input argd dict used #\))))
-       (iter (cdr argl) (acons "__VA_ARGS__" val argv) (read-char))))
-     ((or (eqv? ch #\() (eqv? ch #\,))
-      (let ((val (scan-cpp-input argd dict used #\,)))
-       (iter (cdr argl) (acons (car argl) val argv) (read-char))))
-     (else (error "coding error, ch=" ch)))))
-
-;; @deffn expand-cpp-repl
+;; @deffn {Procedure} expand-cpp-repl
 ;; to be documented
-(define (expand-cpp-repl repl argd dict used)
-  (with-input-from-string repl
-    (lambda () (scan-cpp-input argd dict used #f))))
-
-;; @deffn cpp-expand-text text dict => string
-(define (cpp-expand-text text dict)
+;; @end deffn
+(define (expand-cpp-repl text defs used)
+  ;;(simple-format #t "expand-cpp-repl text=~S used=~S\n" text used)
   (with-input-from-string text
-    (lambda () (scan-cpp-input '() dict '() #f))))
+    (lambda () (scan-cpp-input defs used #f))))
+
+;; === exports =======================
+
+;; @deffn {Procedure} eval-cpp-cond-text text defs => string
+;; Evaluate CPP condition expression (text).
+;; @end deffn
+(define (eval-cpp-cond-text text defs)
+  (with-throw-handler
+   'cpp-error
+   (lambda ()
+     (let* ((rhs (cpp-expand-text text defs))
+           (exp (parse-cpp-expr rhs)))
+       (eval-cpp-expr exp defs)))
+   (lambda (key fmt . args)
+     (report-error fmt args)
+     (throw 'c99-error "CPP error"))))
 
-;; @deffn expand-cpp-macro-ref ident dict => repl|#f
-;; Given an identifier seen in C99 input, this checks for associated
-;; definition in @var{dict} (generated from CPP defines).  If found,
-;; the expansion is returned as a string.  If @var{ident} refers
+;; @deffn {Procedure} expand-cpp-macro-ref ident defs [used] => repl|#f
+;; Given an identifier seen in the current input, this checks for associated
+;; definition in @var{defs} (generated from CPP defines).  If found as simple
+;; macro, the expansion is returned as a string.  If @var{ident} refers
 ;; to a macro with arguments, then the arguments will be read from the
-;; current input.  The format of the @code{dict} entries are
+;; current input.  The format of the @code{defs} entries are
 ;; @example
 ;; ("ABC" . "123")
 ;; ("MAX" ("X" "Y") . "((X)>(Y)?(X):(Y))")
 ;; @end example
-(define (expand-cpp-macro-ref ident dict . rest)
-  (let ((used (if (pair? rest) (car rest) '()))
-       (rval (assoc-ref dict ident)))
+;; @end deffn
+(define* (expand-cpp-macro-ref ident defs #:optional (used '()))
+  (let ((rval (assoc-ref defs ident)))
+    ;;(simple-format #t "ex-mac-ref rval=~S\n" rval)
     (cond
-     ((not rval) #f)
-     ((member ident used) ident)
-     ((string? rval)
-      (let ((expd (expand-cpp-repl rval '() dict (cons ident used))))
-       expd))
+     ((member ident used) #f)
+     ((string? rval) (expand-cpp-repl rval defs (cons ident used)))
      ((pair? rval)
-      (let* ((argl (car rval)) (repl (cdr rval))
-            (argd (collect-args argl '() dict '()))
-            (expd (expand-cpp-repl repl argd dict (cons ident used))))
-       expd))
-     ((c99-std-val ident))
+      ;;(simple-format #t "rval = ~S\n" rval)
+      (and=> (collect-args (car rval) defs used)
+            (lambda (argd)
+              (expand-cpp-repl (px-cpp-ftn argd (cdr rval))
+                               defs (cons ident used)))))
+     ((c99-std-val ident) => identity)
      (else #f))))
 
 ;;; --- last line ---
index 8cf3214abb8cba8a8b3c4efb9a95c61ef18d409a..80be2409981b67be0bfbf18cc1bf3c9cd0feb780 100644 (file)
   (define (xtra-dir path)
     (lang-dir (string-append "mach.d/" path)))
 
-  (write-lalr-actions cpp-mach (xtra-dir "cppact.scm.new"))
-  (write-lalr-tables cpp-mach (xtra-dir "cpptab.scm.new"))
+  (write-lalr-actions cpp-mach (xtra-dir "cppact.scm.new") #:prefix "cpp-")
+  (write-lalr-tables cpp-mach (xtra-dir "cpptab.scm.new") #:prefix "cpp-")
   (let ((a (move-if-changed (xtra-dir "cppact.scm.new")
                            (xtra-dir "cppact.scm")))
        (b (move-if-changed (xtra-dir "cpptab.scm.new")
index 07f6eff67cabd63dd07200bb84393a1389b92acf..f707a4538ff4246ebc2547740af12aecd3778b97 100644 (file)
     1 1 1 1 1 1 1 2 1 1 1 1))
 
 (define c99-pat-v
-  #(((103 . 1) (182 . 2) (95 . -281) (-1 . -281)) ((22 . 3) (28 . 4) (29 . 5
-    ) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 
-    13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 . 18) (27 . 19) (138 . 20)
-    (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27
-    ) (43 . 28) (44 . 29) (45 . 30) (47 . 31) (147 . 32) (148 . 33) (149 . 34)
-    (150 . 35) (1 . 36) (2 . 37) (95 . 38) (170 . 39) (48 . 40) (46 . 41) (
-    100 . 42) (110 . 43) (134 . 44) (106 . 45) (101 . 46) (102 . 47) (97 . 
-    -280)) ((97 . 0)) ((-1 . -233)) ((85 . 85) (6 . 52) (7 . 53) (22 . 3) (138
-    . 80) (181 . 81) (137 . 86)) ((85 . 83) (6 . 52) (7 . 53) (22 . 3) (138 
-    . 80) (181 . 81) (137 . 84)) ((85 . 79) (6 . 52) (7 . 53) (22 . 3) (138 . 
-    80) (181 . 81) (137 . 82)) ((-1 . -138)) ((31 . 78) (-1 . -136)) ((31 . 77
-    ) (-1 . -135)) ((-1 . -132)) ((40 . 73) (38 . 74) (36 . 75) (34 . 76) (-1 
-    . -127)) ((38 . 70) (36 . 71) (32 . 72) (-1 . -116)) ((-1 . -113)) ((40 . 
-    66) (38 . 67) (36 . 68) (34 . 69) (-1 . -114)) ((38 . 65) (-1 . -109)) ((
-    -1 . -176)) ((-1 . -175)) ((-1 . -174)) ((-1 . -173)) ((-1 . -108)) ((-1 
-    . -107)) ((-1 . -106)) ((-1 . -105)) ((-1 . -104)) ((-1 . -103)) ((-1 . 
-    -102)) ((-1 . -101)) ((-1 . -100)) ((-1 . -99)) ((-1 . -98)) ((-1 . -96)) 
+  #(((103 . 1) (182 . 2) (97 . -281) (95 . -281) (-1 . -281)) ((22 . 3) (28 
+    . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 
+    . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 . 18) (27 . 19
+    ) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 
+    26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (47 . 31) (147 . 32) (148 . 33
+    ) (149 . 34) (150 . 35) (1 . 36) (2 . 37) (95 . 38) (170 . 39) (48 . 40) (
+    46 . 41) (100 . 42) (110 . 43) (134 . 44) (106 . 45) (101 . 46) (102 . 47)
+    (97 . -280)) ((97 . 0)) ((-1 . -233)) ((85 . 85) (6 . 52) (7 . 53) (22 . 
+    3) (138 . 80) (181 . 81) (137 . 86)) ((85 . 83) (6 . 52) (7 . 53) (22 . 3)
+    (138 . 80) (181 . 81) (137 . 84)) ((85 . 79) (6 . 52) (7 . 53) (22 . 3) (
+    138 . 80) (181 . 81) (137 . 82)) ((-1 . -138)) ((31 . 78) (-1 . -136)) ((
+    31 . 77) (-1 . -135)) ((-1 . -132)) ((40 . 73) (38 . 74) (36 . 75) (34 . 
+    76) (-1 . -127)) ((38 . 70) (36 . 71) (32 . 72) (-1 . -116)) ((-1 . -113))
+    ((40 . 66) (38 . 67) (36 . 68) (34 . 69) (-1 . -114)) ((38 . 65) (-1 . 
+    -109)) ((-1 . -176)) ((-1 . -175)) ((-1 . -174)) ((-1 . -173)) ((-1 . -108
+    )) ((-1 . -107)) ((-1 . -106)) ((-1 . -105)) ((-1 . -104)) ((-1 . -103)) (
+    (-1 . -102)) ((-1 . -101)) ((-1 . -100)) ((-1 . -99)) ((-1 . -98)) ((-1 . 
+    -96)) ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 
+    . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17
+    ) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24
+    ) (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) 
+    (47 . 31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 64) (-1 . -90
+    )) ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 
+    10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) 
+    (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) 
+    (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (
+    47 . 31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 63) (-1 . -88)
+    ) ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10
+    ) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (
+    26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (
+    142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47
+    . 31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 62) (-1 . -86)) 
     ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) 
     (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 
     . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142
     . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47 . 
-    31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 64) (-1 . -90)) ((
-    22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (
-    35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 
-    . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142
-    . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47 . 
-    31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 63) (-1 . -88)) ((
-    22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (
-    35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 
-    . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142
-    . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47 . 
-    31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 62) (-1 . -86)) ((
-    22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (
-    35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 
-    . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142
-    . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47 . 
     31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 61) (-1 . -84)) ((
-    95 . -306) (-1 . -306)) ((95 . -305) (-1 . -305)) ((95 . -304) (-1 . -304)
-    ) ((146 . 49) (153 . 50) (48 . 51) (6 . 52) (7 . 53) (80 . 54) (93 . 55) (
-    181 . 56) (126 . 57) (127 . 58) (145 . 59)) ((95 . -289) (-1 . -289)) ((8 
-    . 48) (-1 . -97)) ((95 . -287) (-1 . -287)) ((95 . -286) (-1 . -286)) ((95
-    . -285) (-1 . -285)) ((95 . -284) (-1 . -284)) ((95 . -283) (-1 . -283)) 
-    ((95 . -282) (-1 . -282)) ((85 . 126)) ((48 . -92) (83 . -92)) ((152 . 124
-    ) (83 . 125) (48 . -83)) ((94 . 121) (98 . 122) (151 . 123) (95 . -294) (
-    -1 . -294)) ((-1 . -297)) ((-1 . -296)) ((25 . 17) (26 . 18) (27 . 19) (
-    148 . 118) (125 . 119) (80 . 54) (127 . 120) (-1 . -193)) ((6 . 52) (7 . 
-    53) (80 . 54) (93 . 55) (181 . 56) (126 . 57) (127 . 58) (145 . 117)) ((-1
-    . -179)) ((91 . 115) (93 . 116) (-1 . -178)) ((6 . 52) (7 . 53) (93 . 55)
-    (181 . 56) (126 . 114)) ((85 . 108) (115 . 109) (22 . 3) (28 . 4) (29 . 5
-    ) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 
-    13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 . 18) (27 . 19) (138 . 20)
-    (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27
-    ) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47 . 31) (147 . 32) (148 . 33) 
-    (149 . 34) (150 . 35) (170 . 110) (106 . 111) (99 . 112) (59 . 113) (48 . 
-    -94) (83 . -94)) ((-1 . -97)) ((-1 . -85)) ((-1 . -87)) ((-1 . -89)) ((-1 
-    . -91)) ((-1 . -110)) ((38 . 107) (-1 . -111)) ((-1 . -115)) ((36 . 105) (
-    38 . 106) (-1 . -118)) ((-1 . -133)) ((-1 . -117)) ((38 . 104) (-1 . -120)
-    ) ((31 . 103) (-1 . -137)) ((38 . 102) (-1 . -125)) ((-1 . -126)) ((36 . 
-    100) (38 . 101) (-1 . -129)) ((-1 . -134)) ((-1 . -139)) ((-1 . -140)) ((
-    22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (
-    35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 
-    . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (
-    143 . 26) (42 . 27) (148 . 92) (149 . 93) (95 . 38) (133 . 94) (134 . 95) 
-    (135 . 96) (136 . 99)) ((-1 . -149)) ((-1 . -148)) ((85 . 98) (-1 . -144))
-    ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10)
-    (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27
-    . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (
-    143 . 26) (42 . 27) (148 . 92) (149 . 93) (95 . 38) (133 . 94) (134 . 95) 
-    (135 . 96) (136 . 97)) ((85 . 91) (-1 . -147)) ((6 . 52) (7 . 53) (181 . 
-    88) (128 . 89) (129 . 90)) ((85 . 87) (-1 . -168)) ((6 . 52) (7 . 53) (181
-    . 88) (128 . 89) (129 . 228)) ((59 . 227) (84 . -171) (83 . -171)) ((84 
-    . -169) (83 . -169)) ((84 . 225) (83 . 226)) ((22 . 3) (28 . 4) (29 . 5) (
+    95 . -306) (97 . -306) (-1 . -306)) ((95 . -305) (97 . -305) (-1 . -305)) 
+    ((95 . -304) (97 . -304) (-1 . -304)) ((146 . 49) (153 . 50) (48 . 51) (6 
+    . 52) (7 . 53) (80 . 54) (93 . 55) (181 . 56) (126 . 57) (127 . 58) (145 
+    . 59)) ((95 . -289) (97 . -289) (-1 . -289)) ((8 . 48) (-1 . -97)) ((95 . 
+    -287) (97 . -287) (-1 . -287)) ((95 . -286) (97 . -286) (-1 . -286)) ((95 
+    . -285) (97 . -285) (-1 . -285)) ((95 . -284) (97 . -284) (-1 . -284)) ((
+    95 . -283) (97 . -283) (-1 . -283)) ((95 . -282) (97 . -282) (-1 . -282)) 
+    ((85 . 126)) ((48 . -92) (83 . -92)) ((152 . 124) (83 . 125) (48 . -83)) (
+    (94 . 121) (98 . 122) (151 . 123) (97 . -294) (95 . -294) (-1 . -294)) ((
+    -1 . -297)) ((-1 . -296)) ((25 . 17) (26 . 18) (27 . 19) (148 . 118) (125 
+    . 119) (80 . 54) (127 . 120) (-1 . -193)) ((6 . 52) (7 . 53) (80 . 54) (93
+    . 55) (181 . 56) (126 . 57) (127 . 58) (145 . 117)) ((-1 . -179)) ((91 . 
+    115) (93 . 116) (-1 . -178)) ((6 . 52) (7 . 53) (93 . 55) (181 . 56) (126 
+    . 114)) ((85 . 108) (115 . 109) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 
+    7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40
+    . 15) (24 . 16) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 
+    . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 
+    . 29) (45 . 30) (46 . 60) (47 . 31) (147 . 32) (148 . 33) (149 . 34) (150 
+    . 35) (170 . 110) (106 . 111) (99 . 112) (59 . 113) (48 . -94) (83 . -94))
+    ((-1 . -97)) ((-1 . -85)) ((-1 . -87)) ((-1 . -89)) ((-1 . -91)) ((-1 . 
+    -110)) ((38 . 107) (-1 . -111)) ((-1 . -115)) ((36 . 105) (38 . 106) (-1 
+    . -118)) ((-1 . -133)) ((-1 . -117)) ((38 . 104) (-1 . -120)) ((31 . 103) 
+    (-1 . -137)) ((38 . 102) (-1 . -125)) ((-1 . -126)) ((36 . 100) (38 . 101)
+    (-1 . -129)) ((-1 . -134)) ((-1 . -139)) ((-1 . -140)) ((22 . 3) (28 . 4)
+    (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12
+    ) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (
+    139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) 
+    (148 . 92) (149 . 93) (95 . 38) (133 . 94) (134 . 95) (135 . 96) (136 . 99
+    )) ((-1 . -149)) ((-1 . -148)) ((85 . 98) (-1 . -144)) ((22 . 3) (28 . 4) 
+    (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12)
+    (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (
+    139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) 
+    (148 . 92) (149 . 93) (95 . 38) (133 . 94) (134 . 95) (135 . 96) (136 . 97
+    )) ((85 . 91) (-1 . -147)) ((6 . 52) (7 . 53) (181 . 88) (128 . 89) (129 
+    . 90)) ((85 . 87) (-1 . -168)) ((6 . 52) (7 . 53) (181 . 88) (128 . 89) (
+    129 . 228)) ((59 . 227) (84 . -171) (83 . -171)) ((84 . -169) (83 . -169))
+    ((84 . 225) (83 . 226)) ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32
+    . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15)
+    (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23)
+    (41 . 24) (142 . 25) (143 . 26) (42 . 27) (148 . 92) (149 . 93) (95 . 38)
+    (133 . 94) (134 . 95) (135 . 96) (136 . 224)) ((22 . 3) (28 . 4) (29 . 5)
+    (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 
+    13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21
+    ) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) (148 . 
+    92) (149 . 93) (133 . 223) (-1 . -158)) ((22 . 3) (28 . 4) (29 . 5) (30 . 
+    6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 
+    . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 
+    . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) (148 . 92) (149
+    . 93) (133 . 222) (-1 . -156)) ((6 . 52) (7 . 53) (80 . 54) (93 . 55) (
+    181 . 56) (126 . 57) (127 . 58) (60 . 218) (145 . 219) (131 . 220) (132 . 
+    221)) ((95 . -151) (-1 . -151)) ((95 . -150) (-1 . -150)) ((84 . 217) (22 
+    . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 
+    . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19
+    ) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 
+    26) (42 . 27) (148 . 92) (149 . 93) (133 . 94) (135 . 214) (95 . 38) (134 
+    . 215)) ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (
+    34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 
+    . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142
+    . 25) (143 . 26) (42 . 27) (148 . 92) (149 . 93) (95 . 38) (133 . 94) (
+    134 . 95) (135 . 96) (136 . 216)) ((84 . 213) (22 . 3) (28 . 4) (29 . 5) (
     30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13)
     (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (
     140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) (148 . 92) 
-    (149 . 93) (95 . 38) (133 . 94) (134 . 95) (135 . 96) (136 . 224)) ((22 . 
-    3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 
-    11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19) 
-    (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26
-    ) (42 . 27) (148 . 92) (149 . 93) (133 . 223) (-1 . -158)) ((22 . 3) (28 
-    . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 
-    . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19) (138 . 
-    20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 
-    . 27) (148 . 92) (149 . 93) (133 . 222) (-1 . -156)) ((6 . 52) (7 . 53) (
-    80 . 54) (93 . 55) (181 . 56) (126 . 57) (127 . 58) (60 . 218) (145 . 219)
-    (131 . 220) (132 . 221)) ((95 . -151) (-1 . -151)) ((95 . -150) (-1 . 
-    -150)) ((84 . 217) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (
-    33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 
-    17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 
-    24) (142 . 25) (143 . 26) (42 . 27) (148 . 92) (149 . 93) (133 . 94) (135 
-    . 214) (95 . 38) (134 . 215)) ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7
-    ) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 
-    . 15) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 
-    . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) (148 . 92) (149 . 93) (95 
-    . 38) (133 . 94) (134 . 95) (135 . 96) (136 . 216)) ((84 . 213) (22 . 3) (
-    28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (
-    36 . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27 . 19) (138 
-    . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42
-    . 27) (148 . 92) (149 . 93) (133 . 94) (135 . 214) (95 . 38) (134 . 215))
-    ((38 . 212) (-1 . -131)) ((-1 . -128)) ((-1 . -124)) ((-1 . -141)) ((-1 
-    . -121)) ((38 . 211) (-1 . -122)) ((-1 . -119)) ((-1 . -112)) ((166 . 143)
-    (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (
-    8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156)
-    (180 . 157) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 
-    . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170
-    ) (86 . 171) (87 . 172) (176 . 173) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (
-    31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14
-    ) (40 . 15) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (24 . 16) (25 . 17) 
-    (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) 
-    (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (
-    47 . 31) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (
-    13 . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 
-    195) (85 . 108) (20 . 196) (21 . 197) (181 . 198) (147 . 32) (148 . 33) (
-    149 . 34) (150 . 35) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 
-    . 203) (115 . 204) (116 . 205) (170 . 110) (109 . 206) (106 . 207) (107 . 
-    208) (108 . 209) (84 . 210)) ((95 . -291) (-1 . -291)) ((6 . 52) (7 . 53) 
+    (149 . 93) (133 . 94) (135 . 214) (95 . 38) (134 . 215)) ((38 . 212) (-1 
+    . -131)) ((-1 . -128)) ((-1 . -124)) ((-1 . -141)) ((-1 . -121)) ((38 . 
+    211) (-1 . -122)) ((-1 . -119)) ((-1 . -112)) ((166 . 143) (165 . 144) (
+    164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 
+    151) (4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (
+    157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 
+    165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) 
+    (87 . 172) (176 . 173) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 
+    8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (
+    168 . 174) (155 . 175) (6 . 52) (7 . 53) (24 . 16) (25 . 17) (26 . 18) (27
+    . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (
+    143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47 . 31) (172
+    . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14
+    . 190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108)
+    (20 . 196) (21 . 197) (181 . 198) (147 . 32) (148 . 33) (149 . 34) (150 
+    . 35) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 
+    204) (116 . 205) (170 . 110) (109 . 206) (106 . 207) (107 . 208) (108 . 
+    209) (84 . 210)) ((95 . -291) (97 . -291) (-1 . -291)) ((6 . 52) (7 . 53) 
     (80 . 54) (93 . 55) (181 . 56) (126 . 57) (127 . 58) (145 . 128) (146 . 49
     ) (153 . 50) (48 . 51)) ((-1 . -292)) ((85 . 108) (115 . 182) (22 . 3) (28
     . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36
     . 28) (44 . 29) (45 . 30) (46 . 60) (47 . 31) (147 . 32) (148 . 33) (149 
     . 34) (150 . 35) (170 . 137) (121 . 138) (122 . 139) (124 . 140)) ((92 . 
     133)) ((-1 . -196)) ((80 . 54) (127 . 131) (25 . 17) (26 . 18) (27 . 19) (
-    148 . 132) (-1 . -192)) ((-1 . -195)) ((95 . -303) (-1 . -303)) ((95 . 
-    -295) (-1 . -295)) ((95 . -82) (-1 . -82)) ((48 . 130)) ((6 . 52) (7 . 53)
-    (80 . 54) (93 . 55) (181 . 56) (126 . 57) (127 . 58) (145 . 128) (146 . 
-    129)) ((103 . 127) (95 . -281) (-1 . -281)) ((84 . 334) (22 . 3) (28 . 4) 
-    (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12)
-    (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 . 18) (27 . 19) (
-    138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26)
-    (42 . 27) (43 . 28) (44 . 29) (45 . 30) (47 . 31) (147 . 32) (148 . 33) (
-    149 . 34) (150 . 35) (1 . 36) (2 . 37) (95 . 38) (170 . 39) (48 . 40) (46 
-    . 41) (100 . 42) (110 . 43) (134 . 44) (106 . 45) (101 . 46) (102 . 47)) (
-    (59 . 113) (48 . -94) (83 . -94)) ((48 . -93) (83 . -93)) ((94 . 121) (98 
-    . 122) (151 . 333) (95 . -294) (-1 . -294)) ((-1 . -194)) ((-1 . -197)) ((
-    -1 . -180)) ((-1 . -191)) ((92 . -205) (83 . -205)) ((92 . 331) (83 . 332)
-    ) ((6 . 52) (7 . 53) (181 . 56) (126 . 57) (145 . 325) (91 . 326) (93 . 
-    327) (80 . 54) (120 . 328) (127 . 329) (169 . 330) (92 . -204) (83 . -204)
-    ) ((83 . -200) (92 . -200)) ((83 . 324) (92 . -198)) ((92 . 323)) ((25 . 
-    17) (26 . 18) (27 . 19) (148 . 118) (125 . 322)) ((-1 . -184)) ((-1 . -35)
-    ) ((80 . 319) (75 . 320) (74 . 321) (-1 . -39)) ((79 . 317) (78 . 318) (-1
-    . -42)) ((73 . 315) (72 . 316) (-1 . -45)) ((71 . 311) (70 . 312) (69 . 
-    313) (68 . 314) (-1 . -50)) ((67 . 309) (66 . 310) (-1 . -53)) ((81 . 308)
-    (-1 . -55)) ((-1 . -301)) ((-1 . -300)) ((-1 . -299)) ((-1 . -298)) ((65 
-    . 307) (-1 . -57)) ((64 . 306) (-1 . -59)) ((8 . 305) (-1 . -3)) ((-1 . -2
-    )) ((-1 . -1)) ((63 . 304) (-1 . -61)) ((-1 . -32)) ((-1 . -31)) ((-1 . 
-    -30)) ((-1 . -29)) ((90 . 303) (-1 . -28)) ((-1 . -27)) ((166 . 143) (165 
-    . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 
-    150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 
-    155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161)
-    (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 
-    . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174
-    ) (155 . 175) (172 . 184) (178 . 297) (22 . 3) (28 . 4) (29 . 5) (30 . 6) 
-    (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 
-    14) (40 . 15) (24 . 16) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21
-    ) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) (43 . 28
-    ) (44 . 29) (45 . 30) (46 . 60) (47 . 31) (147 . 32) (148 . 298) (149 . 
-    299) (150 . 35) (170 . 300) (133 . 301) (174 . 302)) ((-1 . -5)) ((61 . 
-    295) (62 . 296) (-1 . -63)) ((8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 
-    52) (7 . 53) (179 . 156) (180 . 157) (181 . 158) (76 . 160) (77 . 161) (78
-    . 162) (79 . 163) (80 . 178) (81 . 165) (177 . 167) (82 . 169) (167 . 170
-    ) (86 . 171) (87 . 172) (176 . 173) (168 . 293) (93 . 294)) ((8 . 150) (3 
+    148 . 132) (-1 . -192)) ((-1 . -195)) ((95 . -303) (97 . -303) (-1 . -303)
+    ) ((95 . -295) (97 . -295) (-1 . -295)) ((95 . -82) (97 . -82) (-1 . -82))
+    ((48 . 130)) ((6 . 52) (7 . 53) (80 . 54) (93 . 55) (181 . 56) (126 . 57)
+    (127 . 58) (145 . 128) (146 . 129)) ((103 . 127) (95 . -281) (-1 . -281))
+    ((84 . 334) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9
+    ) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (
+    25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (
+    41 . 24) (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (47
+    . 31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (1 . 36) (2 . 37) (95 
+    . 38) (170 . 39) (48 . 40) (46 . 41) (100 . 42) (110 . 43) (134 . 44) (106
+    . 45) (101 . 46) (102 . 47)) ((59 . 113) (48 . -94) (83 . -94)) ((48 . 
+    -93) (83 . -93)) ((94 . 121) (98 . 122) (151 . 333) (97 . -294) (95 . -294
+    ) (-1 . -294)) ((-1 . -194)) ((-1 . -197)) ((-1 . -180)) ((-1 . -191)) ((
+    92 . -205) (83 . -205)) ((92 . 331) (83 . 332)) ((6 . 52) (7 . 53) (181 . 
+    56) (126 . 57) (145 . 325) (91 . 326) (93 . 327) (80 . 54) (120 . 328) (
+    127 . 329) (169 . 330) (92 . -204) (83 . -204)) ((83 . -200) (92 . -200)) 
+    ((83 . 324) (92 . -198)) ((92 . 323)) ((25 . 17) (26 . 18) (27 . 19) (148 
+    . 118) (125 . 322)) ((-1 . -184)) ((-1 . -35)) ((80 . 319) (75 . 320) (74 
+    . 321) (-1 . -39)) ((79 . 317) (78 . 318) (-1 . -42)) ((73 . 315) (72 . 
+    316) (-1 . -45)) ((71 . 311) (70 . 312) (69 . 313) (68 . 314) (-1 . -50)) 
+    ((67 . 309) (66 . 310) (-1 . -53)) ((81 . 308) (-1 . -55)) ((-1 . -301)) (
+    (-1 . -300)) ((-1 . -299)) ((-1 . -298)) ((65 . 307) (-1 . -57)) ((64 . 
+    306) (-1 . -59)) ((8 . 305) (-1 . -3)) ((-1 . -2)) ((-1 . -1)) ((63 . 304)
+    (-1 . -61)) ((-1 . -32)) ((-1 . -31)) ((-1 . -30)) ((-1 . -29)) ((90 . 
+    303) (-1 . -28)) ((-1 . -27)) ((166 . 143) (165 . 144) (164 . 145) (163 . 
+    146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 
+    . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (
+    181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 
+    178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) 
+    (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 . 184) (178
+    . 297) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34
+    . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 
+    17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 
+    24) (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60
+    ) (47 . 31) (147 . 32) (148 . 298) (149 . 299) (150 . 35) (170 . 300) (133
+    . 301) (174 . 302)) ((-1 . -5)) ((61 . 295) (62 . 296) (-1 . -63)) ((8 . 
+    150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (179 . 156) (180 . 
+    157) (181 . 158) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (
+    81 . 165) (177 . 167) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 
+    173) (168 . 293) (93 . 294)) ((8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 
+    . 52) (7 . 53) (179 . 156) (180 . 157) (181 . 158) (76 . 160) (77 . 161) (
+    78 . 162) (79 . 163) (80 . 178) (81 . 165) (177 . 167) (82 . 169) (167 . 
+    170) (86 . 171) (87 . 172) (176 . 173) (93 . 166) (168 . 231) (166 . 292))
+    ((8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (179 . 156) (
+    180 . 157) (181 . 158) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 
+    178) (81 . 165) (93 . 289) (177 . 167) (82 . 169) (167 . 170) (86 . 171) (
+    87 . 172) (176 . 173) (168 . 291)) ((8 . 150) (3 . 151) (4 . 152) (5 . 153
+    ) (6 . 52) (7 . 53) (179 . 156) (180 . 157) (181 . 158) (76 . 160) (77 . 
+    161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 289) (177 . 167) (
+    82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 290)) ((91 
+    . 283) (93 . 284) (89 . 285) (88 . 286) (87 . 287) (86 . 288) (-1 . -21)) 
+    ((49 . 271) (50 . 272) (51 . 273) (52 . 274) (53 . 275) (54 . 276) (55 . 
+    277) (56 . 278) (57 . 279) (58 . 280) (59 . 281) (154 . 282) (-1 . -33)) (
+    (-1 . -65)) ((90 . 270)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) 
+    (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153
+    ) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (181 
+    . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (81 . 165) 
+    (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 
+    . 172) (176 . 173) (168 . 174) (155 . 175) (172 . 266) (25 . 17) (26 . 18)
+    (27 . 19) (148 . 132) (90 . 267) (44 . 268) (80 . 269)) ((-1 . -28)) ((
+    166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (
+    160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 
+    . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 
+    160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (
+    177 . 167) (89 . 259) (91 . 260) (156 . 168) (82 . 169) (167 . 170) (86 . 
+    171) (87 . 172) (176 . 173) (117 . 261) (168 . 174) (155 . 175) (118 . 262
+    ) (85 . 179) (172 . 180) (144 . 263) (119 . 264) (173 . 265)) ((83 . -234)
+    (84 . -234) (48 . -234)) ((48 . -95) (83 . -95)) ((95 . -290) (97 . -290)
+    (-1 . -290)) ((-1 . -293)) ((-1 . -78)) ((166 . 143) (165 . 144) (164 . 
+    145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (
+    4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (
+    180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 
+    163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (
+    167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 
+    . 184) (178 . 257) (48 . 258)) ((48 . 256)) ((48 . 255)) ((6 . 52) (7 . 53
+    ) (181 . 254)) ((93 . 253)) ((166 . 143) (165 . 144) (164 . 145) (163 . 
+    146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 
+    . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (157 . 159) (76 . 
+    160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (
+    177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 
+    . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 
+    . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (
+    16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (20 . 196) (21 . 
+    197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 
+    203) (115 . 204) (116 . 205) (109 . 252)) ((93 . 251)) ((93 . 250)) ((93 
+    . 249)) ((-1 . -263)) ((48 . 247) (83 . 248)) ((60 . 246)) ((8 . 150) (3 
     . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (179 . 156) (180 . 157) (181 
     . 158) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (
     177 . 167) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (93 . 
-    166) (168 . 231) (166 . 292)) ((8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 
-    . 52) (7 . 53) (179 . 156) (180 . 157) (181 . 158) (76 . 160) (77 . 161) (
-    78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 289) (177 . 167) (82 . 
-    169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 291)) ((8 . 150)
-    (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (179 . 156) (180 . 157) (
-    181 . 158) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 
-    165) (93 . 289) (177 . 167) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (
-    176 . 173) (168 . 290)) ((91 . 283) (93 . 284) (89 . 285) (88 . 286) (87 
-    . 287) (86 . 288) (-1 . -21)) ((49 . 271) (50 . 272) (51 . 273) (52 . 274)
-    (53 . 275) (54 . 276) (55 . 277) (56 . 278) (57 . 279) (58 . 280) (59 . 
-    281) (154 . 282) (-1 . -33)) ((-1 . -65)) ((90 . 270)) ((166 . 143) (165 
+    166) (168 . 231) (166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 
+    147) (161 . 148) (160 . 149) (159 . 154) (158 . 155) (157 . 159) (156 . 
+    168) (155 . 232) (130 . 245)) ((60 . 244) (-1 . -1)) ((-1 . -252)) ((-1 . 
+    -251)) ((-1 . -250)) ((-1 . -249)) ((-1 . -248)) ((-1 . -247)) ((-1 . -246
+    )) ((-1 . -261)) ((-1 . -260)) ((-1 . -258)) ((84 . 242) (166 . 143) (165 
     . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 
-    150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 
-    155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161)
-    (78 . 162) (79 . 163) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 
-    . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 
-    175) (172 . 266) (25 . 17) (26 . 18) (27 . 19) (148 . 132) (90 . 267) (44 
-    . 268) (80 . 269)) ((-1 . -28)) ((166 . 143) (165 . 144) (164 . 145) (163 
-    . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (
-    5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157)
-    (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 
-    . 178) (81 . 165) (93 . 166) (177 . 167) (89 . 259) (91 . 260) (156 . 168)
-    (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (117 . 261) (168
-    . 174) (155 . 175) (118 . 262) (85 . 179) (172 . 180) (144 . 263) (119 . 
-    264) (173 . 265)) ((83 . -234) (84 . -234) (48 . -234)) ((48 . -95) (83 . 
-    -95)) ((95 . -290) (-1 . -290)) ((-1 . -293)) ((-1 . -78)) ((166 . 143) (
-    165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 
-    . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 
-    155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161)
-    (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 
-    . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174
-    ) (155 . 175) (172 . 184) (178 . 257) (48 . 258)) ((48 . 256)) ((48 . 255)
-    ) ((6 . 52) (7 . 53) (181 . 254)) ((93 . 253)) ((166 . 143) (165 . 144) (
-    164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 
-    151) (4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (
-    157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 
-    165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) 
-    (87 . 172) (176 . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 
-    184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 
-    190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (
-    20 . 196) (21 . 197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 
-    . 202) (114 . 203) (115 . 204) (116 . 205) (109 . 252)) ((93 . 251)) ((93 
-    . 250)) ((93 . 249)) ((-1 . -263)) ((48 . 247) (83 . 248)) ((60 . 246)) ((
-    8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (179 . 156) (180 
-    . 157) (181 . 158) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) 
-    (81 . 165) (177 . 167) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 
-    . 173) (93 . 166) (168 . 231) (166 . 143) (165 . 144) (164 . 145) (163 . 
-    146) (162 . 147) (161 . 148) (160 . 149) (159 . 154) (158 . 155) (157 . 
-    159) (156 . 168) (155 . 232) (130 . 245)) ((60 . 244) (-1 . -1)) ((-1 . 
-    -252)) ((-1 . -251)) ((-1 . -250)) ((-1 . -249)) ((-1 . -248)) ((-1 . -247
-    )) ((-1 . -246)) ((-1 . -261)) ((-1 . -260)) ((-1 . -258)) ((84 . 242) (
-    166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (
-    160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 . 154) (158 . 155)
-    (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 
-    . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169)
-    (167 . 170) (86 . 171) (87 . 172) (176 . 173) (22 . 3) (28 . 4) (29 . 5) 
-    (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13
-    ) (37 . 14) (40 . 15) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (24 . 16) 
-    (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) 
-    (41 . 24) (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (
-    46 . 60) (47 . 31) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (
-    12 . 188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) (48 . 194
-    ) (178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198) (147 . 32) (148
-    . 33) (149 . 34) (150 . 35) (110 . 199) (111 . 200) (112 . 201) (113 . 
-    202) (114 . 203) (115 . 204) (116 . 205) (170 . 110) (109 . 206) (106 . 
-    207) (107 . 243)) ((95 . -257) (-1 . -257)) ((-1 . -123)) ((-1 . -130)) ((
+    150) (3 . 151) (4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (
+    180 . 157) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 
+    178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) 
+    (86 . 171) (87 . 172) (176 . 173) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 
+    . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (
+    40 . 15) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (24 . 16) (25 . 17) (26
+    . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) (
+    142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47
+    . 31) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13
+    . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 195)
+    (85 . 108) (20 . 196) (21 . 197) (181 . 198) (147 . 32) (148 . 33) (149 
+    . 34) (150 . 35) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 
+    203) (115 . 204) (116 . 205) (170 . 110) (109 . 206) (106 . 207) (107 . 
+    243)) ((95 . -257) (97 . -257) (-1 . -257)) ((-1 . -123)) ((-1 . -130)) ((
     -1 . -143)) ((95 . -152) (-1 . -152)) ((95 . -153) (-1 . -153)) ((84 . 241
     ) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10)
     (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (25 . 17) (26 . 18) (27
     170) (86 . 171) (87 . 172) (176 . 173) (93 . 166) (168 . 231) (166 . 143) 
     (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (
     159 . 154) (158 . 155) (157 . 159) (156 . 168) (155 . 232) (130 . 409)) ((
-    48 . -163) (83 . -163)) ((-1 . -142)) ((95 . -256) (-1 . -256)) ((-1 . 
-    -259)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 
-    . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 . 154) (
-    158 . 155) (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 . 161) (78 
-    . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168)
-    (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155
-    . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 
-    187) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) (48
-    . 194) (178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198) (110 . 
-    199) (111 . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 204) (116 . 
-    205) (109 . 408)) ((60 . 407)) ((166 . 143) (165 . 144) (164 . 145) (163 
-    . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (
-    5 . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (157 . 159) (76 
-    . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (
-    177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 
-    . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 
-    . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (
-    16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (20 . 196) (21 . 
-    197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 
-    203) (115 . 204) (116 . 205) (109 . 406)) ((-1 . -262)) ((166 . 143) (165 
-    . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 
-    150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 
+    48 . -163) (83 . -163)) ((-1 . -142)) ((95 . -256) (97 . -256) (-1 . -256)
+    ) ((-1 . -259)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 
+    147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 
+    . 154) (158 . 155) (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 . 
+    161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (
+    156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 
+    . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 . 185) (10 . 
+    186) (11 . 187) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19
+    . 193) (48 . 194) (178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198
+    ) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 204) 
+    (116 . 205) (109 . 408)) ((60 . 407)) ((166 . 143) (165 . 144) (164 . 145)
+    (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 
+    152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (157 . 159)
+    (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 
+    166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) 
+    (176 . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37)
+    (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 190) (15 . 
+    191) (16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (20 . 196) (
+    21 . 197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114
+    . 203) (115 . 204) (116 . 205) (109 . 406)) ((-1 . -262)) ((166 . 143) (
+    165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 
+    150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 
     155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161)
     (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 
     . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174
     327) (181 . 56) (126 . 57) (127 . 329) (145 . 117)) ((91 . 337) (93 . 338)
     (92 . -211) (83 . -211)) ((91 . 326) (120 . 336) (6 . 52) (7 . 53) (93 . 
     327) (181 . 56) (126 . 114) (92 . -209) (83 . -209)) ((92 . -203) (83 . 
-    -203)) ((-1 . -190)) ((6 . 52) (7 . 53) (181 . 335)) ((95 . -81) (-1 . -81
-    )) ((95 . -288) (-1 . -288)) ((92 . -206) (83 . -206)) ((91 . 337) (93 . 
-    338) (92 . -210) (83 . -210)) ((44 . 446) (90 . 447) (166 . 143) (165 . 
-    144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150)
-    (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (
-    179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 
-    . 162) (79 . 163) (80 . 448) (81 . 165) (93 . 166) (177 . 167) (156 . 168)
-    (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155
-    . 175) (172 . 449) (25 . 17) (26 . 18) (27 . 19) (148 . 118) (125 . 450))
-    ((92 . 444) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9
-    ) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (
-    25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (
-    41 . 24) (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46
-    . 60) (47 . 31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 137) (
-    121 . 138) (122 . 139) (124 . 445)) ((92 . 443)) ((92 . 442)) ((-1 . -232)
-    ) ((90 . 441)) ((-1 . -223)) ((25 . 17) (26 . 18) (27 . 19) (148 . 118) (
-    125 . 440)) ((44 . 437) (25 . 17) (26 . 18) (27 . 19) (148 . 132) (90 . 
-    438) (166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 
+    -203)) ((-1 . -190)) ((6 . 52) (7 . 53) (181 . 335)) ((95 . -81) (97 . -81
+    ) (-1 . -81)) ((95 . -288) (97 . -288) (-1 . -288)) ((92 . -206) (83 . 
+    -206)) ((91 . 337) (93 . 338) (92 . -210) (83 . -210)) ((44 . 446) (90 . 
+    447) (166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 
     148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53)
     (159 . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (
-    76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166
+    76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 448) (81 . 165) (93 . 166
     ) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (
-    176 . 173) (168 . 174) (155 . 175) (172 . 439)) ((90 . 436) (-1 . -28)) ((
-    83 . -201) (92 . -201)) ((92 . -199)) ((90 . 435)) ((-1 . -38)) ((-1 . -37
-    )) ((-1 . -36)) ((80 . 319) (75 . 320) (74 . 321) (-1 . -41)) ((80 . 319) 
-    (75 . 320) (74 . 321) (-1 . -40)) ((79 . 317) (78 . 318) (-1 . -44)) ((79 
-    . 317) (78 . 318) (-1 . -43)) ((73 . 315) (72 . 316) (-1 . -49)) ((73 . 
-    315) (72 . 316) (-1 . -48)) ((73 . 315) (72 . 316) (-1 . -47)) ((73 . 315)
-    (72 . 316) (-1 . -46)) ((71 . 311) (70 . 312) (69 . 313) (68 . 314) (-1 
-    . -52)) ((71 . 311) (70 . 312) (69 . 313) (68 . 314) (-1 . -51)) ((67 . 
-    309) (66 . 310) (-1 . -54)) ((81 . 308) (-1 . -56)) ((65 . 307) (-1 . -58)
-    ) ((64 . 306) (-1 . -60)) ((85 . 433) (8 . 150) (3 . 151) (4 . 152) (5 . 
-    153) (6 . 52) (7 . 53) (179 . 156) (180 . 157) (181 . 158) (76 . 160) (77 
-    . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (177 . 167) (82 . 169) 
-    (167 . 170) (86 . 171) (87 . 172) (176 . 173) (93 . 166) (168 . 231) (166 
-    . 434)) ((91 . 326) (93 . 368) (80 . 54) (120 . 328) (127 . 369) (169 . 
-    339) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 
-    10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) 
-    (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41 . 24) 
-    (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (
-    47 . 31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 137) (121 . 
-    138) (122 . 139) (124 . 340) (92 . 341)) ((91 . 326) (93 . 368) (120 . 336
-    ) (92 . -209) (83 . -209)) ((92 . -207)) ((-1 . -4)) ((63 . 304) (-1 . -62
-    )) ((60 . 432) (83 . 248)) ((92 . 431)) ((92 . 430)) ((-1 . -10)) ((-1 . 
-    -9)) ((-1 . -8)) ((91 . 326) (93 . 368) (80 . 54) (120 . 328) (127 . 369) 
-    (169 . 429) (92 . -20) (83 . -20)) ((92 . -17) (83 . -17)) ((92 . -15) (83
-    . -15)) ((92 . 427) (83 . 428)) ((90 . 426) (83 . 248)) ((-1 . -66)) ((-1
-    . -187)) ((90 . 425)) ((-1 . -181)) ((166 . 143) (165 . 144) (164 . 145) 
-    (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 
-    152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 
-    . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163)
-    (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 
-    . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (85 . 179
-    ) (172 . 180) (144 . 422) (89 . 259) (91 . 260) (117 . 261) (118 . 262) (
-    119 . 423) (84 . 424)) ((83 . -235) (84 . -235) (48 . -235)) ((83 . -237) 
-    (84 . -237)) ((-1 . -241)) ((59 . -243) (89 . -243) (91 . -243)) ((90 . 
-    421)) ((59 . -245) (91 . -245) (89 . -245)) ((-1 . -278)) ((-1 . -275)) ((
-    -1 . -272)) ((-1 . -271)) ((48 . 420) (83 . 248)) ((166 . 143) (165 . 144)
-    (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 
-    . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 
-    . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162
-    ) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 
-    . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 
-    175) (172 . 184) (178 . 418) (104 . 419) (48 . -273)) ((93 . 417)) ((92 . 
-    416) (83 . 248)) ((92 . 415) (83 . 248)) ((83 . 248) (92 . 414)) ((-1 . 
-    -79)) ((-1 . -255)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 
-    . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (
-    159 . 154) (158 . 155) (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 
-    . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) 
-    (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 
-    . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 . 185) (10 . 
-    186) (11 . 187) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19
-    . 193) (48 . 194) (178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198
-    ) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 204) 
-    (116 . 205) (109 . 413)) ((-1 . -253)) ((48 . -162) (83 . -162)) ((48 . 
-    -160) (83 . -160)) ((95 . -154) (-1 . -154)) ((-1 . -165)) ((-1 . -254)) (
-    (166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (
-    160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 . 154) (158 . 155)
-    (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 
-    . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169)
-    (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (6 
-    . 52) (7 . 53) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 
-    188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (
-    178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198) (110 . 199) (111 
-    . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 204) (116 . 205) (109 . 
-    471)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 
-    148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 . 154) (158 
-    . 155) (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 . 161) (78 . 162
-    ) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 
-    . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 
-    175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 187
-    ) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) (48 . 
-    194) (178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198) (110 . 199) 
-    (111 . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 204) (116 . 205) (
-    109 . 470)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (
-    161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 . 154)
-    (158 . 155) (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 . 161) (78
-    . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168
-    ) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (
-    155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11
-    . 187) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) 
-    (48 . 194) (178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198) (110 
-    . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 204) (116 . 
-    205) (109 . 469)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 
-    147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 
-    52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158) (
-    157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 
-    165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) 
-    (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 . 184) (178 . 468)) ((
-    83 . 248) (48 . -274) (92 . -274)) ((48 . 467)) ((-1 . -270)) ((59 . -244)
-    (91 . -244) (89 . -244)) ((83 . -240) (84 . -240)) ((166 . 143) (165 . 
-    144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150)
-    (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (
-    179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 
-    . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168)
-    (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155
-    . 175) (85 . 179) (172 . 180) (144 . 466)) ((83 . -236) (84 . -236) (48 
-    . -236)) ((-1 . -186)) ((-1 . -6)) ((-1 . -7)) ((22 . 3) (28 . 4) (29 . 5)
-    (30 . 6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 
-    13) (37 . 14) (40 . 15) (24 . 16) (25 . 17) (26 . 18) (27 . 19) (138 . 20)
-    (139 . 21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27
-    ) (43 . 28) (44 . 29) (45 . 30) (46 . 60) (47 . 31) (147 . 32) (148 . 33) 
-    (149 . 34) (150 . 35) (170 . 379) (171 . 464) (166 . 143) (165 . 144) (164
-    . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151
-    ) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156
-    ) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79
-    . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169
-    ) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (
-    172 . 465)) ((92 . -19) (83 . -19)) ((85 . 433)) ((85 . 433) (-1 . -26)) (
-    (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (179 . 156) (180
-    . 157) (181 . 158) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178)
-    (81 . 165) (177 . 167) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 
-    . 173) (93 . 166) (168 . 231) (166 . 143) (165 . 144) (164 . 145) (163 . 
-    146) (162 . 147) (161 . 148) (160 . 149) (159 . 154) (158 . 155) (157 . 
-    159) (156 . 168) (155 . 463)) ((166 . 143) (165 . 144) (164 . 145) (163 . 
+    176 . 173) (168 . 174) (155 . 175) (172 . 449) (25 . 17) (26 . 18) (27 . 
+    19) (148 . 118) (125 . 450)) ((92 . 444) (22 . 3) (28 . 4) (29 . 5) (30 . 
+    6) (31 . 7) (32 . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 
+    . 14) (40 . 15) (24 . 16) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 
+    21) (140 . 22) (141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) (43 . 
+    28) (44 . 29) (45 . 30) (46 . 60) (47 . 31) (147 . 32) (148 . 33) (149 . 
+    34) (150 . 35) (170 . 137) (121 . 138) (122 . 139) (124 . 445)) ((92 . 443
+    )) ((92 . 442)) ((-1 . -232)) ((90 . 441)) ((-1 . -223)) ((25 . 17) (26 . 
+    18) (27 . 19) (148 . 118) (125 . 440)) ((44 . 437) (25 . 17) (26 . 18) (27
+    . 19) (148 . 132) (90 . 438) (166 . 143) (165 . 144) (164 . 145) (163 . 
     146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 
     . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (
     181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 
-    178) (81 . 165) (93 . 166) (177 . 167) (89 . 259) (91 . 260) (156 . 168) (
-    82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (117 . 261) (168 
-    . 174) (155 . 175) (118 . 262) (85 . 179) (172 . 180) (144 . 263) (119 . 
-    264) (173 . 462)) ((-1 . -34)) ((-1 . -185)) ((-1 . -228)) ((166 . 143) (
+    178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) 
+    (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 . 439)) ((
+    90 . 436) (-1 . -28)) ((83 . -201) (92 . -201)) ((92 . -199)) ((90 . 435))
+    ((-1 . -38)) ((-1 . -37)) ((-1 . -36)) ((80 . 319) (75 . 320) (74 . 321) 
+    (-1 . -41)) ((80 . 319) (75 . 320) (74 . 321) (-1 . -40)) ((79 . 317) (78 
+    . 318) (-1 . -44)) ((79 . 317) (78 . 318) (-1 . -43)) ((73 . 315) (72 . 
+    316) (-1 . -49)) ((73 . 315) (72 . 316) (-1 . -48)) ((73 . 315) (72 . 316)
+    (-1 . -47)) ((73 . 315) (72 . 316) (-1 . -46)) ((71 . 311) (70 . 312) (69
+    . 313) (68 . 314) (-1 . -52)) ((71 . 311) (70 . 312) (69 . 313) (68 . 314
+    ) (-1 . -51)) ((67 . 309) (66 . 310) (-1 . -54)) ((81 . 308) (-1 . -56)) (
+    (65 . 307) (-1 . -58)) ((64 . 306) (-1 . -60)) ((85 . 433) (8 . 150) (3 . 
+    151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (179 . 156) (180 . 157) (181 . 
+    158) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (
+    177 . 167) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (93 . 
+    166) (168 . 231) (166 . 434)) ((91 . 326) (93 . 368) (80 . 54) (120 . 328)
+    (127 . 369) (169 . 339) (22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 
+    . 8) (33 . 9) (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) 
+    (24 . 16) (25 . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (
+    141 . 23) (41 . 24) (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (
+    45 . 30) (46 . 60) (47 . 31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (
+    170 . 137) (121 . 138) (122 . 139) (124 . 340) (92 . 341)) ((91 . 326) (93
+    . 368) (120 . 336) (92 . -209) (83 . -209)) ((92 . -207)) ((-1 . -4)) ((
+    63 . 304) (-1 . -62)) ((60 . 432) (83 . 248)) ((92 . 431)) ((92 . 430)) ((
+    -1 . -10)) ((-1 . -9)) ((-1 . -8)) ((91 . 326) (93 . 368) (80 . 54) (120 
+    . 328) (127 . 369) (169 . 429) (92 . -20) (83 . -20)) ((92 . -17) (83 . 
+    -17)) ((92 . -15) (83 . -15)) ((92 . 427) (83 . 428)) ((90 . 426) (83 . 
+    248)) ((-1 . -66)) ((-1 . -187)) ((90 . 425)) ((-1 . -181)) ((166 . 143) (
     165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 
     . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 
     155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161)
     (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 
     . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174
-    ) (155 . 175) (172 . 461)) ((-1 . -221)) ((90 . 460)) ((166 . 143) (165 . 
-    144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150)
-    (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (
-    179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 
-    . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168)
-    (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155
-    . 175) (172 . 458) (25 . 17) (26 . 18) (27 . 19) (148 . 132) (90 . 459)) 
-    ((-1 . -222)) ((-1 . -231)) ((-1 . -212)) ((-1 . -230)) ((92 . 457)) ((25 
-    . 17) (26 . 18) (27 . 19) (148 . 118) (125 . 456)) ((-1 . -216)) ((90 . 
-    455) (-1 . -28)) ((90 . 454)) ((166 . 143) (165 . 144) (164 . 145) (163 . 
+    ) (155 . 175) (85 . 179) (172 . 180) (144 . 422) (89 . 259) (91 . 260) (
+    117 . 261) (118 . 262) (119 . 423) (84 . 424)) ((83 . -235) (84 . -235) (
+    48 . -235)) ((83 . -237) (84 . -237)) ((-1 . -241)) ((59 . -243) (89 . 
+    -243) (91 . -243)) ((90 . 421)) ((59 . -245) (91 . -245) (89 . -245)) ((-1
+    . -278)) ((-1 . -275)) ((-1 . -272)) ((-1 . -271)) ((48 . 420) (83 . 248)
+    ) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148)
+    (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (
+    159 . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76
+    . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) 
+    (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 
+    . 173) (168 . 174) (155 . 175) (172 . 184) (178 . 418) (104 . 419) (48 . 
+    -273)) ((93 . 417)) ((92 . 416) (83 . 248)) ((92 . 415) (83 . 248)) ((83 
+    . 248) (92 . 414)) ((-1 . -79)) ((-1 . -255)) ((166 . 143) (165 . 144) (
+    164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 
+    151) (4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (
+    157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 
+    165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) 
+    (87 . 172) (176 . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 
+    184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 
+    190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (
+    20 . 196) (21 . 197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 
+    . 202) (114 . 203) (115 . 204) (116 . 205) (109 . 413)) ((-1 . -253)) ((48
+    . -162) (83 . -162)) ((48 . -160) (83 . -160)) ((95 . -154) (-1 . -154)) 
+    ((-1 . -165)) ((-1 . -254)) ((166 . 143) (165 . 144) (164 . 145) (163 . 
+    146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 
+    . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (157 . 159) (76 . 
+    160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (
+    177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 
+    . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 
+    . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (
+    16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (20 . 196) (21 . 
+    197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 
+    203) (115 . 204) (116 . 205) (109 . 471)) ((166 . 143) (165 . 144) (164 . 
+    145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (
+    4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (157 . 
+    159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93
+    . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 
+    172) (176 . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 
+    . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 190) (15
+    . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (20 . 196)
+    (21 . 197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 . 202) (
+    114 . 203) (115 . 204) (116 . 205) (109 . 470)) ((166 . 143) (165 . 144) (
+    164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 
+    151) (4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (
+    157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 
+    165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) 
+    (87 . 172) (176 . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 
+    184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 
+    190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (
+    20 . 196) (21 . 197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 
+    . 202) (114 . 203) (115 . 204) (116 . 205) (109 . 469)) ((166 . 143) (165 
+    . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 
+    150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 
+    155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161)
+    (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 
+    . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174
+    ) (155 . 175) (172 . 184) (178 . 468)) ((83 . 248) (48 . -274) (92 . -274)
+    ) ((48 . 467)) ((-1 . -270)) ((59 . -244) (91 . -244) (89 . -244)) ((83 . 
+    -240) (84 . -240)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 
+    . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 
+    . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158)
+    (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 
+    165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) 
+    (87 . 172) (176 . 173) (168 . 174) (155 . 175) (85 . 179) (172 . 180) (144
+    . 466)) ((83 . -236) (84 . -236) (48 . -236)) ((-1 . -186)) ((-1 . -6)) (
+    (-1 . -7)) ((22 . 3) (28 . 4) (29 . 5) (30 . 6) (31 . 7) (32 . 8) (33 . 9)
+    (34 . 10) (35 . 11) (36 . 12) (38 . 13) (37 . 14) (40 . 15) (24 . 16) (25
+    . 17) (26 . 18) (27 . 19) (138 . 20) (139 . 21) (140 . 22) (141 . 23) (41
+    . 24) (142 . 25) (143 . 26) (42 . 27) (43 . 28) (44 . 29) (45 . 30) (46 
+    . 60) (47 . 31) (147 . 32) (148 . 33) (149 . 34) (150 . 35) (170 . 379) (
+    171 . 464) (166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (
+    161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7
+    . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158) (157 . 
+    159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93
+    . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 
+    172) (176 . 173) (168 . 174) (155 . 175) (172 . 465)) ((92 . -19) (83 . 
+    -19)) ((85 . 433)) ((85 . 433) (-1 . -26)) ((8 . 150) (3 . 151) (4 . 152) 
+    (5 . 153) (6 . 52) (7 . 53) (179 . 156) (180 . 157) (181 . 158) (76 . 160)
+    (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (177 . 167) (82 . 
+    169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (93 . 166) (168 . 231) 
+    (166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (
+    160 . 149) (159 . 154) (158 . 155) (157 . 159) (156 . 168) (155 . 463)) ((
+    166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (
+    160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 
+    . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 
+    160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (
+    177 . 167) (89 . 259) (91 . 260) (156 . 168) (82 . 169) (167 . 170) (86 . 
+    171) (87 . 172) (176 . 173) (117 . 261) (168 . 174) (155 . 175) (118 . 262
+    ) (85 . 179) (172 . 180) (144 . 263) (119 . 264) (173 . 462)) ((-1 . -34))
+    ((-1 . -185)) ((-1 . -228)) ((166 . 143) (165 . 144) (164 . 145) (163 . 
     146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 
     . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (
     181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 
     178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) 
-    (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 . 451) (25 
-    . 17) (26 . 18) (27 . 19) (148 . 132) (90 . 452) (44 . 453)) ((90 . 482)
-    ((-1 . -214)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147)
-    (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) 
-    (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158) (157 
-    . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (
-    93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 
-    172) (176 . 173) (168 . 174) (155 . 175) (172 . 481)) ((-1 . -215)) ((-1 
-    . -227)) ((90 . 479) (25 . 17) (26 . 18) (27 . 19) (148 . 132) (166 . 143)
-    (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (
-    8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 
-    . 155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 
-    161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (
-    156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 
-    . 174) (155 . 175) (172 . 480)) ((-1 . -229)) ((90 . 478)) ((-1 . -225)) (
-    (-1 . -220)) ((90 . 477)) ((84 . 475) (83 . 476)) ((-1 . -64)) ((92 . -18)
-    (83 . -18)) ((92 . -16) (83 . -16)) ((83 . -239) (84 . -239)) ((166 . 143
-    ) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) 
-    (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158
+    (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 . 461)) ((
+    -1 . -221)) ((90 . 460)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146
+    (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153
+    ) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (181 
+    . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) 
+    (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 
+    . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 . 458) (25 . 17
+    ) (26 . 18) (27 . 19) (148 . 132) (90 . 459)) ((-1 . -222)) ((-1 . -231)) 
+    ((-1 . -212)) ((-1 . -230)) ((92 . 457)) ((25 . 17) (26 . 18) (27 . 19) (
+    148 . 118) (125 . 456)) ((-1 . -216)) ((90 . 455) (-1 . -28)) ((90 . 454))
+    ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) 
+    (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159
+    . 154) (158 . 155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 
+    160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (
+    177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 
+    . 173) (168 . 174) (155 . 175) (172 . 451) (25 . 17) (26 . 18) (27 . 19) (
+    148 . 132) (90 . 452) (44 . 453)) ((90 . 482)) ((-1 . -214)) ((166 . 143) 
+    (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8
+    . 150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 
     . 155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 
     161) (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (
     156 . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 
-    . 174) (155 . 175) (172 . 184) (178 . 418) (104 . 474) (92 . -273)) ((92 
-    . 473) (83 . 248)) ((-1 . -267)) ((-1 . -266)) ((17 . 472) (-1 . -264)) ((
-    166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (
-    160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 . 154) (158 . 155)
-    (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 
-    . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169)
-    (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (6 
-    . 52) (7 . 53) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 
-    188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (
-    178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198) (110 . 199) (111 
-    . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 204) (116 . 205) (109 . 
-    488)) ((48 . 487)) ((92 . 486)) ((-1 . -13)) ((84 . 485) (166 . 143) (165 
+    . 174) (155 . 175) (172 . 481)) ((-1 . -215)) ((-1 . -227)) ((90 . 479) (
+    25 . 17) (26 . 18) (27 . 19) (148 . 132) (166 . 143) (165 . 144) (164 . 
+    145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (
+    4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (
+    180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 
+    163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (
+    167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 
+    . 480)) ((-1 . -229)) ((90 . 478)) ((-1 . -225)) ((-1 . -220)) ((90 . 477)
+    ) ((84 . 475) (83 . 476)) ((-1 . -64)) ((92 . -18) (83 . -18)) ((92 . -16)
+    (83 . -16)) ((83 . -239) (84 . -239)) ((166 . 143) (165 . 144) (164 . 145
+    ) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 
+    . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (
+    180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 
+    163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (
+    167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (172 
+    . 184) (178 . 418) (104 . 474) (92 . -273)) ((92 . 473) (83 . 248)) ((-1 
+    . -267)) ((-1 . -266)) ((17 . 472) (-1 . -264)) ((166 . 143) (165 . 144) (
+    164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 
+    151) (4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (180 . 157) (
+    157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 178) (81 . 
+    165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) (86 . 171) 
+    (87 . 172) (176 . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53) (172 . 
+    184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 189) (14 . 
+    190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 195) (85 . 108) (
+    20 . 196) (21 . 197) (181 . 198) (110 . 199) (111 . 200) (112 . 201) (113 
+    . 202) (114 . 203) (115 . 204) (116 . 205) (109 . 488)) ((48 . 487)) ((92 
+    . 486)) ((-1 . -13)) ((84 . 485) (166 . 143) (165 . 144) (164 . 145) (163 
+    . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (
+    5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 155) (179 . 156) (180 . 157)
+    (181 . 158) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 
+    . 178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170
+    ) (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (85 . 179) (
+    172 . 180) (144 . 422) (89 . 259) (91 . 260) (117 . 261) (118 . 262) (119 
+    . 423)) ((-1 . -226)) ((-1 . -224)) ((-1 . -218)) ((90 . 484)) ((90 . 483)
+    ) ((-1 . -213)) ((-1 . -219)) ((-1 . -217)) ((-1 . -14)) ((166 . 143) (165
     . 144) (164 . 145) (163 . 146) (162 . 147) (161 . 148) (160 . 149) (8 . 
-    150) (3 . 151) (4 . 152) (5 . 153) (6 . 52) (7 . 53) (159 . 154) (158 . 
-    155) (179 . 156) (180 . 157) (181 . 158) (157 . 159) (76 . 160) (77 . 161)
-    (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 
-    . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174
-    ) (155 . 175) (85 . 179) (172 . 180) (144 . 422) (89 . 259) (91 . 260) (
-    117 . 261) (118 . 262) (119 . 423)) ((-1 . -226)) ((-1 . -224)) ((-1 . 
-    -218)) ((90 . 484)) ((90 . 483)) ((-1 . -213)) ((-1 . -219)) ((-1 . -217))
-    ((-1 . -14)) ((166 . 143) (165 . 144) (164 . 145) (163 . 146) (162 . 147)
-    (161 . 148) (160 . 149) (8 . 150) (3 . 151) (4 . 152) (5 . 153) (159 . 
-    154) (158 . 155) (179 . 156) (180 . 157) (157 . 159) (76 . 160) (77 . 161)
-    (78 . 162) (79 . 163) (80 . 178) (81 . 165) (93 . 166) (177 . 167) (156 
-    . 168) (82 . 169) (167 . 170) (86 . 171) (87 . 172) (176 . 173) (168 . 174
-    ) (155 . 175) (6 . 52) (7 . 53) (172 . 184) (2 . 37) (9 . 185) (10 . 186) 
-    (11 . 187) (12 . 188) (13 . 189) (14 . 190) (15 . 191) (16 . 192) (19 . 
-    193) (48 . 194) (178 . 195) (85 . 108) (20 . 196) (21 . 197) (181 . 198) (
-    110 . 199) (111 . 200) (112 . 201) (113 . 202) (114 . 203) (115 . 204) (
-    116 . 205) (109 . 489)) ((-1 . -268)) ((-1 . -265)) ((-1 . -269))))
+    150) (3 . 151) (4 . 152) (5 . 153) (159 . 154) (158 . 155) (179 . 156) (
+    180 . 157) (157 . 159) (76 . 160) (77 . 161) (78 . 162) (79 . 163) (80 . 
+    178) (81 . 165) (93 . 166) (177 . 167) (156 . 168) (82 . 169) (167 . 170) 
+    (86 . 171) (87 . 172) (176 . 173) (168 . 174) (155 . 175) (6 . 52) (7 . 53
+    ) (172 . 184) (2 . 37) (9 . 185) (10 . 186) (11 . 187) (12 . 188) (13 . 
+    189) (14 . 190) (15 . 191) (16 . 192) (19 . 193) (48 . 194) (178 . 195) (
+    85 . 108) (20 . 196) (21 . 197) (181 . 198) (110 . 199) (111 . 200) (112 
+    . 201) (113 . 202) (114 . 203) (115 . 204) (116 . 205) (109 . 489)) ((-1 
+    . -268)) ((-1 . -265)) ((-1 . -269))))
 
 (define c99-rto-v
   #(#f 177 177 177 177 176 176 176 176 176 176 176 176 176 176 175 175 175 
index f8152eed9d6f2dd3b7d827b5984605b270cd9a7d..38e1bcea9a39d3a93b4a2d016e2199189cd3d4d4 100644 (file)
     179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (
     79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (
     167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 . 36) 
-    (178 . 37)) ((-1 . -35)) ((80 . 119) (75 . 120) (74 . 121) (-1 . -39)) ((
-    79 . 117) (78 . 118) (-1 . -42)) ((73 . 115) (72 . 116) (-1 . -45)) ((71 
-    . 111) (70 . 112) (69 . 113) (68 . 114) (-1 . -50)) ((67 . 109) (66 . 110)
-    (-1 . -53)) ((81 . 108) (-1 . -55)) ((-1 . -301)) ((-1 . -300)) ((-1 . 
-    -299)) ((-1 . -298)) ((-1 . -297)) ((-1 . -296)) ((65 . 107) (-1 . -57)) (
-    (64 . 106) (-1 . -59)) ((8 . 105) (-1 . -3)) ((-1 . -2)) ((-1 . -1)) ((63 
-    . 104) (-1 . -61)) ((-1 . -32)) ((-1 . -31)) ((-1 . -30)) ((-1 . -29)) ((
-    -1 . -28)) ((-1 . -27)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5)
-    (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (
-    159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20)
-    (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (
-    156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (
-    155 . 35) (172 . 36) (178 . 66) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (
-    31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 
-    . 78) (40 . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 
-    85) (140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 
-    92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 98) (149 . 
-    99) (150 . 100) (170 . 101) (133 . 102) (174 . 103)) ((-1 . -5)) ((61 . 64
-    ) (62 . 65) (-1 . -63)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 
-    13) (179 . 16) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 
-    23) (80 . 24) (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32
-    ) (176 . 33) (168 . 62) (93 . 63)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 
-    . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 
-    22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31
-    ) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (166 . 61)) ((8 . 8) (3 . 9) (
-    4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76 . 
-    20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 57) (177 . 27)
-    (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 59)) ((8 . 8) 
-    (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 
-    18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 57) 
-    (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 58))
-    ((91 . 51) (93 . 52) (89 . 53) (88 . 54) (87 . 55) (86 . 56) (-1 . -21)) 
-    ((49 . 39) (50 . 40) (51 . 41) (52 . 42) (53 . 43) (54 . 44) (55 . 45) (56
-    . 46) (57 . 47) (58 . 48) (59 . 49) (154 . 50) (-1 . -33)) ((-1 . -65)) (
-    (-1 . -78)) ((83 . 38) (97 . 0)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) 
-    (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (
-    7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) 
-    (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177
-    . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168
-    . 34) (155 . 35) (172 . 190)) ((-1 . -77)) ((-1 . -76)) ((-1 . -75)) ((-1
-    . -74)) ((-1 . -73)) ((-1 . -72)) ((-1 . -71)) ((-1 . -70)) ((-1 . -69)) 
-    ((-1 . -68)) ((-1 . -67)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 
-    5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13)
-    (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 
-    20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27)
-    (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34)
-    (155 . 35) (172 . 189)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5
-    ) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) 
-    (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20
-    ) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (
-    156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (
-    155 . 35) (172 . 36) (178 . 188)) ((92 . 183) (166 . 1) (165 . 2) (164 . 3
-    ) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11
-    ) (6 . 12) (7 . 13) (159 . 14) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31
-    . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 
-    78) (40 . 79) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (24 . 80) (25 . 
-    81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 
-    88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 94) (46 . 95
-    ) (47 . 96) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (
-    81 . 25) (93 . 26) (177 . 27) (147 . 97) (148 . 146) (149 . 147) (150 . 
-    100) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 
-    . 34) (155 . 35) (170 . 184) (171 . 185) (172 . 186) (175 . 187)) ((6 . 12
-    ) (7 . 13) (181 . 182)) ((6 . 12) (7 . 13) (181 . 181)) ((-1 . -11)) ((-1 
-    . -12)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 
-    . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24 . 80
-    ) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87
-    ) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 94) 
-    (46 . 95) (47 . 96) (147 . 97) (148 . 98) (149 . 99) (150 . 100) (170 . 
-    101) (133 . 102) (174 . 180) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 
-    . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 
-    13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 
-    . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 
-    27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 
-    34) (155 . 35) (172 . 36) (178 . 66)) ((-1 . -22)) ((-1 . -23)) ((-1 . -33
-    )) ((-1 . -24)) ((-1 . -25)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 
-    . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78
-    ) (40 . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) 
-    (140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) 
-    (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 98) (149 . 99) (
-    150 . 100) (170 . 101) (133 . 102) (174 . 179) (166 . 1) (165 . 2) (164 . 
-    3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 
-    11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 
-    18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25)
-    (93 . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) 
-    (176 . 33) (168 . 34) (155 . 35) (172 . 36) (178 . 66)) ((166 . 1) (165 . 
-    2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 
-    10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17)
-    (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (
-    81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (
-    87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 . 36) (178 . 178)) ((8 . 8)
-    (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 
-    18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27)
-    (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) 
-    (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (159
-    . 14) (158 . 15) (157 . 177)) ((92 . 176) (83 . 38)) ((-1 . -233)) ((85 
-    . 174) (6 . 12) (7 . 13) (22 . 67) (138 . 169) (181 . 170) (137 . 175)) ((
-    85 . 172) (6 . 12) (7 . 13) (22 . 67) (138 . 169) (181 . 170) (137 . 173))
-    ((85 . 168) (6 . 12) (7 . 13) (22 . 67) (138 . 169) (181 . 170) (137 . 
-    171)) ((-1 . -138)) ((31 . 167) (-1 . -136)) ((31 . 166) (-1 . -135)) ((-1
-    . -132)) ((40 . 162) (38 . 163) (36 . 164) (34 . 165) (-1 . -127)) ((38 
-    . 159) (36 . 160) (32 . 161) (-1 . -116)) ((-1 . -113)) ((40 . 155) (38 . 
-    156) (36 . 157) (34 . 158) (-1 . -114)) ((38 . 154) (-1 . -109)) ((-1 . 
-    -176)) ((-1 . -175)) ((-1 . -174)) ((-1 . -173)) ((-1 . -108)) ((-1 . -107
-    )) ((-1 . -106)) ((-1 . -105)) ((-1 . -104)) ((-1 . -103)) ((-1 . -102)) (
-    (-1 . -101)) ((-1 . -100)) ((-1 . -99)) ((-1 . -98)) ((-1 . -97)) ((-1 . 
-    -96)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 
-    73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24 . 80) 
-    (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) 
-    (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 94) (
-    46 . 95) (47 . 96) (147 . 97) (148 . 146) (149 . 147) (150 . 100) (170 . 
-    153) (-1 . -90)) ((24 . 80) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 
-    96) (147 . 97) (150 . 100) (170 . 151) (22 . 67) (28 . 68) (29 . 69) (30 
-    . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77
-    ) (37 . 78) (40 . 79) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) 
-    (140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (148 . 98)
-    (149 . 99) (133 . 152) (92 . -88) (80 . -158) (91 . -158) (93 . -158)) ((
-    24 . 80) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (150
-    . 100) (170 . 149) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 
-    . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79
-    ) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87
-    ) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (148 . 98) (149 . 99) (133 . 
-    150) (92 . -86) (80 . -156) (91 . -156) (93 . -156)) ((22 . 67) (28 . 68) 
-    (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 
-    . 76) (38 . 77) (37 . 78) (40 . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83
-    ) (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 
-    90) (42 . 91) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97)
-    (148 . 146) (149 . 147) (150 . 100) (170 . 148) (-1 . -84)) ((92 . -208))
-    ((91 . 140) (93 . 141) (80 . 142) (120 . 143) (127 . 144) (169 . 145)) ((
-    92 . 139)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16)
-    (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (
-    81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (
-    93 . 26) (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161
-    . 6) (160 . 7) (159 . 14) (158 . 138)) ((-1 . -302)) ((8 . 8) (3 . 9) (4 
+    (178 . 37)) ((97 . -35) (-1 . -35)) ((80 . 119) (75 . 120) (74 . 121) (97 
+    . -39) (-1 . -39)) ((79 . 117) (78 . 118) (97 . -42) (-1 . -42)) ((73 . 
+    115) (72 . 116) (97 . -45) (-1 . -45)) ((71 . 111) (70 . 112) (69 . 113) (
+    68 . 114) (97 . -50) (-1 . -50)) ((67 . 109) (66 . 110) (97 . -53) (-1 . 
+    -53)) ((81 . 108) (97 . -55) (-1 . -55)) ((97 . -301) (-1 . -301)) ((97 . 
+    -300) (-1 . -300)) ((97 . -299) (-1 . -299)) ((97 . -298) (-1 . -298)) ((
+    97 . -297) (-1 . -297)) ((97 . -296) (-1 . -296)) ((65 . 107) (97 . -57) (
+    -1 . -57)) ((64 . 106) (97 . -59) (-1 . -59)) ((8 . 105) (97 . -3) (-1 . 
+    -3)) ((97 . -2) (-1 . -2)) ((97 . -1) (-1 . -1)) ((63 . 104) (97 . -61) (
+    -1 . -61)) ((-1 . -32)) ((-1 . -31)) ((-1 . -30)) ((-1 . -29)) ((-1 . -28)
+    ) ((-1 . -27)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6
+    ) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14)
+    (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21
+    ) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) 
+    (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) 
+    (172 . 36) (178 . 66) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (
+    32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 
+    . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 
+    . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 
+    . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 98) (149 . 99) (150 
+    . 100) (170 . 101) (133 . 102) (174 . 103)) ((97 . -5) (-1 . -5)) ((61 . 
+    64) (62 . 65) (97 . -63) (-1 . -63)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6
+    . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 
+    . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 
+    31) (87 . 32) (176 . 33) (168 . 62) (93 . 63)) ((8 . 8) (3 . 9) (4 . 10) (
+    5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76 . 20) (77 
+    . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (82 . 29) (167 . 
+    30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (166 . 61)) ((8 . 
+    8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 
+    . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 57
+    ) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 59
+    )) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 
+    17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25)
+    (93 . 57) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) 
+    (168 . 58)) ((91 . 51) (93 . 52) (89 . 53) (88 . 54) (87 . 55) (86 . 56) (
+    97 . -21) (-1 . -21)) ((49 . 39) (50 . 40) (51 . 41) (52 . 42) (53 . 43) (
+    54 . 44) (55 . 45) (56 . 46) (57 . 47) (58 . 48) (59 . 49) (154 . 50) (97 
+    . -33) (-1 . -33)) ((97 . -65) (-1 . -65)) ((97 . -78) (-1 . -78)) ((83 . 
+    38) (97 . 0)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6)
+    (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) 
+    (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21)
+    (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (
+    82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (
+    172 . 190)) ((-1 . -77)) ((-1 . -76)) ((-1 . -75)) ((-1 . -74)) ((-1 . -73
+    )) ((-1 . -72)) ((-1 . -71)) ((-1 . -70)) ((-1 . -69)) ((-1 . -68)) ((-1 
+    . -67)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 
+    . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 
+    . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 
+    . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 
+    29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 
+    . 189)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 
+    . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 
+    . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 
+    . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 
+    29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 
+    . 36) (178 . 188)) ((92 . 183) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (
+    162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7
+    . 13) (159 . 14) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 
+    72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) 
+    (158 . 15) (179 . 16) (180 . 17) (181 . 18) (24 . 80) (25 . 81) (26 . 82) 
+    (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 88) (142 . 89)
+    (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (
+    157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 
+    . 26) (177 . 27) (147 . 97) (148 . 146) (149 . 147) (150 . 100) (156 . 28)
+    (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35)
+    (170 . 184) (171 . 185) (172 . 186) (175 . 187)) ((6 . 12) (7 . 13) (181 
+    . 182)) ((6 . 12) (7 . 13) (181 . 181)) ((97 . -11) (-1 . -11)) ((97 . -12
+    ) (-1 . -12)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72)
+    (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24
+    . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141
+    . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 
+    . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 98) (149 . 99) (150 . 100) (
+    170 . 101) (133 . 102) (174 . 180) (166 . 1) (165 . 2) (164 . 3) (163 . 4)
+    (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) 
+    (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19)
+    (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (
+    177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (
+    168 . 34) (155 . 35) (172 . 36) (178 . 66)) ((97 . -22) (-1 . -22)) ((97 
+    . -23) (-1 . -23)) ((97 . -33) (-1 . -33)) ((97 . -24) (-1 . -24)) ((97 . 
+    -25) (-1 . -25)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 
+    72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) 
+    (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (
+    141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (
+    45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 98) (149 . 99) (150 . 100) 
+    (170 . 101) (133 . 102) (174 . 179) (166 . 1) (165 . 2) (164 . 3) (163 . 4
+    ) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12)
+    (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19
+    ) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (
+    177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (
+    168 . 34) (155 . 35) (172 . 36) (178 . 66)) ((166 . 1) (165 . 2) (164 . 3)
+    (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11)
+    (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) 
+    (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93
+    . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176
+    . 33) (168 . 34) (155 . 35) (172 . 36) (178 . 178)) ((8 . 8) (3 . 9) (4 
     . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76 . 20
     ) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (82 . 29) (
     167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (166 . 1) (
-    165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (159 . 137)) ((
-    8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (
+    165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (159 . 14) (158
+    . 15) (157 . 177)) ((92 . 176) (83 . 38)) ((-1 . -233)) ((85 . 174) (6 . 
+    12) (7 . 13) (22 . 67) (138 . 169) (181 . 170) (137 . 175)) ((85 . 172) (6
+    . 12) (7 . 13) (22 . 67) (138 . 169) (181 . 170) (137 . 173)) ((85 . 168)
+    (6 . 12) (7 . 13) (22 . 67) (138 . 169) (181 . 170) (137 . 171)) ((-1 . 
+    -138)) ((31 . 167) (-1 . -136)) ((31 . 166) (-1 . -135)) ((-1 . -132)) ((
+    40 . 162) (38 . 163) (36 . 164) (34 . 165) (-1 . -127)) ((38 . 159) (36 . 
+    160) (32 . 161) (-1 . -116)) ((-1 . -113)) ((40 . 155) (38 . 156) (36 . 
+    157) (34 . 158) (-1 . -114)) ((38 . 154) (-1 . -109)) ((-1 . -176)) ((-1 
+    . -175)) ((-1 . -174)) ((-1 . -173)) ((-1 . -108)) ((-1 . -107)) ((-1 . 
+    -106)) ((-1 . -105)) ((-1 . -104)) ((-1 . -103)) ((-1 . -102)) ((-1 . -101
+    )) ((-1 . -100)) ((-1 . -99)) ((-1 . -98)) ((-1 . -97)) ((-1 . -96)) ((22 
+    . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74
+    ) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24 . 80) (25 . 81) (
+    26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 88) (
+    142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47
+    . 96) (147 . 97) (148 . 146) (149 . 147) (150 . 100) (170 . 153) (-1 . 
+    -90)) ((24 . 80) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 
+    97) (150 . 100) (170 . 151) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 
+    71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) 
+    (40 . 79) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (
+    141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (148 . 98) (149 . 99) 
+    (133 . 152) (92 . -88) (80 . -158) (91 . -158) (93 . -158)) ((24 . 80) (43
+    . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (150 . 100) (170
+    . 149) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 
+    73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (25 . 81) 
+    (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 88) 
+    (142 . 89) (143 . 90) (42 . 91) (148 . 98) (149 . 99) (133 . 150) (92 . 
+    -86) (80 . -156) (91 . -156) (93 . -156)) ((22 . 67) (28 . 68) (29 . 69) (
+    30 . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 
+    . 77) (37 . 78) (40 . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 
+    84) (139 . 85) (140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 
+    . 91) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 
+    146) (149 . 147) (150 . 100) (170 . 148) (-1 . -84)) ((92 . -208)) ((91 . 
+    140) (93 . 141) (80 . 142) (120 . 143) (127 . 144) (169 . 145)) ((92 . 139
+    )) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 
+    17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25)
+    (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) 
+    (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (
+    160 . 7) (159 . 14) (158 . 138)) ((97 . -302) (-1 . -302)) ((8 . 8) (3 . 9
+    ) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76
+    . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (82 . 
+    29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (166 . 
+    1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (159 . 137)
+    ) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 
+    17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25)
+    (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) 
+    (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (
+    160 . 136)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16
+    ) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) 
+    (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (
+    93 . 26) (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161
+    . 135)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (
+    180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81
+    . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 
+    . 26) (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 134)) ((8 
+    . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (
     181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177
     . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 
-    . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 
-    136)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180
-    . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 
-    25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 
-    26) (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 
-    135)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180
-    . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 
-    25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 
-    26) (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 134)) ((8 . 
-    8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 
-    . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 
-    27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 
-    60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 133)) ((8 . 8) (3 . 9) 
-    (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76 
+    . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 133)) ((8 . 8) (3 . 9
+    ) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76
     . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (82 . 
     29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (166 . 
     1) (165 . 2) (164 . 3) (163 . 132)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 
     166 . 123)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16
     ) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) 
     (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (
-    93 . 26) (168 . 60) (166 . 122)) ((-1 . -38)) ((-1 . -37)) ((-1 . -36)) ((
-    80 . 119) (75 . 120) (74 . 121) (-1 . -41)) ((80 . 119) (75 . 120) (74 . 
-    121) (-1 . -40)) ((79 . 117) (78 . 118) (-1 . -44)) ((79 . 117) (78 . 118)
-    (-1 . -43)) ((73 . 115) (72 . 116) (-1 . -49)) ((73 . 115) (72 . 116) (-1
-    . -48)) ((73 . 115) (72 . 116) (-1 . -47)) ((73 . 115) (72 . 116) (-1 . 
-    -46)) ((71 . 111) (70 . 112) (69 . 113) (68 . 114) (-1 . -52)) ((71 . 111)
-    (70 . 112) (69 . 113) (68 . 114) (-1 . -51)) ((67 . 109) (66 . 110) (-1 
-    . -54)) ((81 . 108) (-1 . -56)) ((65 . 107) (-1 . -58)) ((64 . 106) (-1 . 
-    -60)) ((85 . 237) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179
-    . 16) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 
-    . 24) (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 
-    . 33) (93 . 26) (168 . 60) (166 . 238)) ((166 . 1) (165 . 2) (164 . 3) (
-    163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (
-    6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (
-    157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (81 . 25) (93 . 26) (177
-    . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168
-    . 34) (155 . 35) (172 . 232) (90 . 233) (44 . 234) (25 . 81) (26 . 82) (
-    27 . 83) (148 . 223) (125 . 235) (80 . 236)) ((91 . 140) (93 . 141) (80 . 
-    142) (120 . 143) (127 . 144) (169 . 226) (22 . 67) (28 . 68) (29 . 69) (30
-    . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 
-    77) (37 . 78) (40 . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84)
-    (139 . 85) (140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91
-    ) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 146)
-    (149 . 147) (150 . 100) (170 . 227) (121 . 228) (122 . 229) (124 . 230) (
-    92 . 231)) ((25 . 81) (26 . 82) (27 . 83) (148 . 223) (125 . 224) (80 . 
-    142) (127 . 225) (-1 . -193)) ((91 . 221) (93 . 222) (92 . -211) (83 . 
-    -211)) ((91 . 140) (93 . 141) (120 . 220) (92 . -209) (83 . -209)) ((92 . 
-    -207)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 
-    73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24 . 80) 
-    (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) 
-    (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 94) (
-    46 . 95) (47 . 96) (147 . 97) (148 . 146) (149 . 147) (150 . 100) (170 . 
-    151) (-1 . -88)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 
-    72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) 
-    (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (
+    93 . 26) (168 . 60) (166 . 122)) ((97 . -38) (-1 . -38)) ((97 . -37) (-1 
+    . -37)) ((97 . -36) (-1 . -36)) ((80 . 119) (75 . 120) (74 . 121) (97 . 
+    -41) (-1 . -41)) ((80 . 119) (75 . 120) (74 . 121) (97 . -40) (-1 . -40)) 
+    ((79 . 117) (78 . 118) (97 . -44) (-1 . -44)) ((79 . 117) (78 . 118) (97 
+    . -43) (-1 . -43)) ((73 . 115) (72 . 116) (97 . -49) (-1 . -49)) ((73 . 
+    115) (72 . 116) (97 . -48) (-1 . -48)) ((73 . 115) (72 . 116) (97 . -47) (
+    -1 . -47)) ((73 . 115) (72 . 116) (97 . -46) (-1 . -46)) ((71 . 111) (70 
+    . 112) (69 . 113) (68 . 114) (97 . -52) (-1 . -52)) ((71 . 111) (70 . 112)
+    (69 . 113) (68 . 114) (97 . -51) (-1 . -51)) ((67 . 109) (66 . 110) (97 
+    . -54) (-1 . -54)) ((81 . 108) (97 . -56) (-1 . -56)) ((65 . 107) (97 . 
+    -58) (-1 . -58)) ((64 . 106) (97 . -60) (-1 . -60)) ((85 . 237) (8 . 8) (3
+    . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18)
+    (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (
+    82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (
+    166 . 238)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (
+    160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (
+    158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) 
+    (78 . 22) (79 . 23) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (
+    167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 . 232)
+    (90 . 233) (44 . 234) (25 . 81) (26 . 82) (27 . 83) (148 . 223) (125 . 
+    235) (80 . 236)) ((91 . 140) (93 . 141) (80 . 142) (120 . 143) (127 . 144)
+    (169 . 226) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (
+    33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24 
+    . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 
+    . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 
+    94) (46 . 95) (47 . 96) (147 . 97) (148 . 146) (149 . 147) (150 . 100) (
+    170 . 227) (121 . 228) (122 . 229) (124 . 230) (92 . 231)) ((25 . 81) (26 
+    . 82) (27 . 83) (148 . 223) (125 . 224) (80 . 142) (127 . 225) (-1 . -193)
+    ) ((91 . 221) (93 . 222) (92 . -211) (83 . -211)) ((91 . 140) (93 . 141) (
+    120 . 220) (92 . -209) (83 . -209)) ((92 . -207)) ((22 . 67) (28 . 68) (29
+    . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 
+    76) (38 . 77) (37 . 78) (40 . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83) 
+    (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90
+    ) (42 . 91) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (
+    148 . 146) (149 . 147) (150 . 100) (170 . 151) (-1 . -88)) ((22 . 67) (28 
+    . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75
+    ) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24 . 80) (25 . 81) (26 . 82) (
+    27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 88) (142 . 89) 
+    (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 94) (46 . 95) (47 . 96) (
+    147 . 97) (148 . 146) (149 . 147) (150 . 100) (170 . 149) (-1 . -86)) ((-1
+    . -85)) ((-1 . -87)) ((-1 . -155)) ((-1 . -89)) ((-1 . -157)) ((-1 . -91)
+    ) ((-1 . -110)) ((38 . 219) (-1 . -111)) ((-1 . -115)) ((36 . 217) (38 . 
+    218) (-1 . -118)) ((-1 . -133)) ((-1 . -117)) ((38 . 216) (-1 . -120)) ((
+    31 . 215) (-1 . -137)) ((38 . 214) (-1 . -125)) ((-1 . -126)) ((36 . 212) 
+    (38 . 213) (-1 . -129)) ((-1 . -134)) ((-1 . -139)) ((-1 . -140)) ((22 . 
+    67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) 
+    (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (25 . 81) (26 . 82) (27 
+    . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 88) (142 . 89) (
+    143 . 90) (42 . 91) (148 . 203) (149 . 204) (95 . 205) (133 . 206) (134 . 
+    207) (135 . 208) (136 . 211)) ((-1 . -149)) ((-1 . -148)) ((85 . 210) (-1 
+    . -144)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 
+    . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (25 . 81
+    ) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 87) (41 . 88
+    ) (142 . 89) (143 . 90) (42 . 91) (148 . 203) (149 . 204) (95 . 205) (133 
+    . 206) (134 . 207) (135 . 208) (136 . 209)) ((85 . 202) (-1 . -147)) ((6 
+    . 12) (7 . 13) (181 . 199) (128 . 200) (129 . 201)) ((85 . 198) (-1 . -168
+    )) ((97 . -4) (-1 . -4)) ((63 . 104) (97 . -62) (-1 . -62)) ((60 . 197) (
+    83 . 38)) ((92 . 196)) ((92 . 195)) ((97 . -10) (-1 . -10)) ((97 . -9) (-1
+    . -9)) ((97 . -8) (-1 . -8)) ((91 . 140) (93 . 141) (80 . 142) (120 . 143
+    ) (127 . 144) (169 . 194) (92 . -20) (83 . -20)) ((92 . -17) (83 . -17)) (
+    (92 . -15) (83 . -15)) ((92 . 192) (83 . 193)) ((90 . 191) (83 . 38)) ((97
+    . -66) (-1 . -66)) ((97 . -79) (-1 . -79)) ((97 . -6) (-1 . -6)) ((97 . 
+    -7) (-1 . -7)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72
+    ) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (
+    24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (
     141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (
     45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 146) (149 . 147) (150 . 100
-    ) (170 . 149) (-1 . -86)) ((-1 . -85)) ((-1 . -87)) ((-1 . -155)) ((-1 . 
-    -89)) ((-1 . -157)) ((-1 . -91)) ((-1 . -110)) ((38 . 219) (-1 . -111)) ((
-    -1 . -115)) ((36 . 217) (38 . 218) (-1 . -118)) ((-1 . -133)) ((-1 . -117)
-    ) ((38 . 216) (-1 . -120)) ((31 . 215) (-1 . -137)) ((38 . 214) (-1 . -125
-    )) ((-1 . -126)) ((36 . 212) (38 . 213) (-1 . -129)) ((-1 . -134)) ((-1 . 
-    -139)) ((-1 . -140)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (
-    32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 
-    . 79) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 
-    . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (148 . 203) (149 . 204) (
-    95 . 205) (133 . 206) (134 . 207) (135 . 208) (136 . 211)) ((-1 . -149)) (
-    (-1 . -148)) ((85 . 210) (-1 . -144)) ((22 . 67) (28 . 68) (29 . 69) (30 
-    . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77
-    ) (37 . 78) (40 . 79) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) 
-    (140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (148 . 203
-    ) (149 . 204) (95 . 205) (133 . 206) (134 . 207) (135 . 208) (136 . 209)) 
-    ((85 . 202) (-1 . -147)) ((6 . 12) (7 . 13) (181 . 199) (128 . 200) (129 
-    . 201)) ((85 . 198) (-1 . -168)) ((-1 . -4)) ((63 . 104) (-1 . -62)) ((60 
-    . 197) (83 . 38)) ((92 . 196)) ((92 . 195)) ((-1 . -10)) ((-1 . -9)) ((-1 
-    . -8)) ((91 . 140) (93 . 141) (80 . 142) (120 . 143) (127 . 144) (169 . 
-    194) (92 . -20) (83 . -20)) ((92 . -17) (83 . -17)) ((92 . -15) (83 . -15)
-    ) ((92 . 192) (83 . 193)) ((90 . 191) (83 . 38)) ((-1 . -66)) ((-1 . -79))
-    ((-1 . -6)) ((-1 . -7)) ((22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71
-    ) (32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (
-    40 . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (
-    140 . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (
-    44 . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 146) (149 . 147) 
-    (150 . 100) (170 . 184) (171 . 291) (166 . 1) (165 . 2) (164 . 3) (163 . 4
-    ) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12)
-    (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19
-    ) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (
-    177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (
-    168 . 34) (155 . 35) (172 . 292)) ((92 . -19) (83 . -19)) ((85 . 237)) ((
-    85 . 237) (-1 . -26)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13)
+    ) (170 . 184) (171 . 291) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5
+    ) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) 
+    (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20
+    ) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (
+    156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (
+    155 . 35) (172 . 292)) ((92 . -19) (83 . -19)) ((85 . 237)) ((85 . 237) (
+    97 . -26) (-1 . -26)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13)
     (179 . 16) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) 
     (80 . 24) (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (
     176 . 33) (93 . 26) (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (
     (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (89 . 239) (
     91 . 240) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (
     117 . 241) (168 . 34) (155 . 35) (118 . 242) (85 . 243) (172 . 244) (144 
-    . 245) (119 . 246) (173 . 247)) ((-1 . -34)) ((6 . 12) (7 . 13) (181 . 329
-    )) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 
-    17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25)
-    (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) 
-    (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (
-    160 . 7) (159 . 14) (158 . 15) (157 . 19) (156 . 28) (155 . 295) (130 . 
-    328)) ((59 . -242) (89 . -242) (91 . -242)) ((59 . 326) (89 . 239) (91 . 
-    240) (117 . 327)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 
-    . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 
-    14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 
-    . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (89 . 
-    239) (91 . 240) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 
-    . 33) (117 . 241) (168 . 34) (155 . 35) (118 . 242) (85 . 243) (172 . 244)
-    (144 . 245) (119 . 246) (173 . 325)) ((84 . -234) (83 . -234)) ((84 . 
-    -238) (83 . -238)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161
-    . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 
-    . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77
-    . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 
-    . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 
-    . 35) (85 . 243) (172 . 244) (144 . 324)) ((84 . 322) (83 . 323)) ((-1 . 
-    -228)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 
-    . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 
-    . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 
-    . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 
-    29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 
-    . 321)) ((-1 . -197)) ((-1 . -221)) ((90 . 320)) ((166 . 1) (165 . 2) (164
-    . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 
-    . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 
-    . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 
-    25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 
-    32) (176 . 33) (168 . 34) (155 . 35) (172 . 318) (25 . 81) (26 . 82) (27 
+    . 245) (119 . 246) (173 . 247)) ((97 . -34) (-1 . -34)) ((6 . 12) (7 . 13)
+    (181 . 329)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (179 . 
+    16) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24
+    ) (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33)
+    (93 . 26) (168 . 60) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (
+    161 . 6) (160 . 7) (159 . 14) (158 . 15) (157 . 19) (156 . 28) (155 . 295)
+    (130 . 328)) ((59 . -242) (89 . -242) (91 . -242)) ((59 . 326) (89 . 239)
+    (91 . 240) (117 . 327)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5
+    ) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) 
+    (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20
+    ) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (
+    89 . 239) (91 . 240) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (
+    176 . 33) (117 . 241) (168 . 34) (155 . 35) (118 . 242) (85 . 243) (172 . 
+    244) (144 . 245) (119 . 246) (173 . 325)) ((84 . -234) (83 . -234)) ((84 
+    . -238) (83 . -238)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (
+    161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (
+    159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20)
+    (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (
+    156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (
+    155 . 35) (85 . 243) (172 . 244) (144 . 324)) ((84 . 322) (83 . 323)) ((-1
+    . -228)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (
+    160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (
+    158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) 
+    (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (
+    82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (
+    172 . 321)) ((-1 . -197)) ((-1 . -221)) ((90 . 320)) ((166 . 1) (165 . 2) 
+    (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10)
+    (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (
+    181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81
+    . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 
+    . 32) (176 . 33) (168 . 34) (155 . 35) (172 . 318) (25 . 81) (26 . 82) (27
     . 83) (148 . 250) (90 . 319)) ((-1 . -222)) ((-1 . -231)) ((22 . 67) (28 
     . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33 . 73) (34 . 74) (35 . 75
     ) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24 . 80) (25 . 81) (26 . 82) (
     (167 . 30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (166 . 1) 
     (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (159 . 14) (
     158 . 15) (157 . 19) (156 . 28) (155 . 295) (130 . 296)) ((83 . 293) (84 
-    . 294)) ((-1 . -64)) ((92 . -18) (83 . -18)) ((92 . -16) (83 . -16)) ((6 
-    . 12) (7 . 13) (181 . 199) (128 . 298) (84 . 357)) ((-1 . -164)) ((-1 . 
-    -80)) ((84 . -172) (83 . -172)) ((-1 . -167)) ((84 . -170) (83 . -170)) ((
-    -1 . -145)) ((94 . 354) (98 . 355) (151 . 356) (95 . -294) (-1 . -294)) ((
-    6 . 12) (7 . 13) (80 . 142) (93 . 279) (181 . 257) (126 . 258) (127 . 280)
-    (60 . 281) (145 . 282) (131 . 353)) ((8 . 8) (3 . 9) (4 . 10) (5 . 11) (6
-    . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76 . 20) (77 . 21) (78 
-    . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (82 . 29) (167 . 30) (86 . 
-    31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (166 . 1) (165 . 2) (164 . 3
-    ) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (159 . 14) (158 . 15) (157 . 19)
-    (156 . 28) (155 . 295) (130 . 352)) ((48 . -163) (83 . -163)) ((91 . 314)
-    (93 . 315) (-1 . -177)) ((92 . 351)) ((-1 . -142)) ((90 . 350)) ((-1 . 
-    -214)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 
-    . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 
-    . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 
-    . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 
-    29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 
-    . 349)) ((-1 . -215)) ((-1 . -227)) ((90 . 347) (25 . 81) (26 . 82) (27 . 
-    83) (148 . 250) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6
+    . 294)) ((97 . -64) (-1 . -64)) ((92 . -18) (83 . -18)) ((92 . -16) (83 . 
+    -16)) ((6 . 12) (7 . 13) (181 . 199) (128 . 298) (84 . 357)) ((-1 . -164))
+    ((-1 . -80)) ((84 . -172) (83 . -172)) ((-1 . -167)) ((84 . -170) (83 . 
+    -170)) ((-1 . -145)) ((94 . 354) (98 . 355) (151 . 356) (95 . -294) (-1 . 
+    -294)) ((6 . 12) (7 . 13) (80 . 142) (93 . 279) (181 . 257) (126 . 258) (
+    127 . 280) (60 . 281) (145 . 282) (131 . 353)) ((8 . 8) (3 . 9) (4 . 10) (
+    5 . 11) (6 . 12) (7 . 13) (179 . 16) (180 . 17) (181 . 18) (76 . 20) (77 
+    . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (177 . 27) (82 . 29) (167 . 
+    30) (86 . 31) (87 . 32) (176 . 33) (93 . 26) (168 . 60) (166 . 1) (165 . 2
+    ) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (159 . 14) (158 . 15) 
+    (157 . 19) (156 . 28) (155 . 295) (130 . 352)) ((48 . -163) (83 . -163)) (
+    (91 . 314) (93 . 315) (-1 . -177)) ((92 . 351)) ((-1 . -142)) ((90 . 350))
+    ((-1 . -214)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6
     ) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14)
     (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21
     ) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) 
     (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) 
-    (172 . 348)) ((-1 . -229)) ((44 . 342) (90 . 343) (166 . 1) (165 . 2) (164
-    . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 
-    . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 
-    . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 344) (81 . 
-    25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 
-    32) (176 . 33) (168 . 34) (155 . 35) (172 . 345) (25 . 81) (26 . 82) (27 
-    . 83) (148 . 223) (125 . 346)) ((92 . 338) (6 . 12) (7 . 13) (181 . 339) (
-    123 . 340) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (32 . 72) (33
-    . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 . 79) (24 . 
-    80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 . 86) (141 . 
-    87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 . 93) (45 . 94
-    ) (46 . 95) (47 . 96) (147 . 97) (148 . 146) (149 . 147) (150 . 100) (170 
-    . 227) (121 . 228) (122 . 229) (124 . 341)) ((83 . -201) (92 . -201)) ((92
-    . -199)) ((90 . 337)) ((-1 . -225)) ((-1 . -220)) ((90 . 336)) ((-1 . -13
-    )) ((84 . 333) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6)
-    (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) 
-    (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21)
-    (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (
-    82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (
-    85 . 243) (172 . 244) (144 . 334) (89 . 239) (91 . 240) (117 . 241) (118 
-    . 242) (119 . 335)) ((84 . -237) (83 . -237)) ((83 . 331) (84 . 332)) ((-1
-    . -241)) ((59 . -243) (89 . -243) (91 . -243)) ((90 . 330)) ((59 . -245) 
-    (91 . -245) (89 . -245)) ((59 . -244) (91 . -244) (89 . -244)) ((166 . 1) 
-    (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9
-    ) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (
-    180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (
-    80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (
-    86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (85 . 243) (172 . 244)
-    (144 . 334) (89 . 239) (91 . 240) (117 . 241) (118 . 242) (119 . 335) (84
-    . 371)) ((84 . -235) (83 . -235)) ((-1 . -14)) ((84 . -240) (83 . -240)) 
-    ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 
+    (172 . 349)) ((-1 . -215)) ((-1 . -227)) ((90 . 347) (25 . 81) (26 . 82) (
+    27 . 83) (148 . 250) (166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (
+    161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (
+    159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20)
+    (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (
+    156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (
+    155 . 35) (172 . 348)) ((-1 . -229)) ((44 . 342) (90 . 343) (166 . 1) (165
+    . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4
+    . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 
+    17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 
+    344) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 
+    31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 . 345) (25 . 81) (26 
+    . 82) (27 . 83) (148 . 223) (125 . 346)) ((92 . 338) (6 . 12) (7 . 13) (
+    181 . 339) (123 . 340) (22 . 67) (28 . 68) (29 . 69) (30 . 70) (31 . 71) (
+    32 . 72) (33 . 73) (34 . 74) (35 . 75) (36 . 76) (38 . 77) (37 . 78) (40 
+    . 79) (24 . 80) (25 . 81) (26 . 82) (27 . 83) (138 . 84) (139 . 85) (140 
+    . 86) (141 . 87) (41 . 88) (142 . 89) (143 . 90) (42 . 91) (43 . 92) (44 
+    . 93) (45 . 94) (46 . 95) (47 . 96) (147 . 97) (148 . 146) (149 . 147) (
+    150 . 100) (170 . 227) (121 . 228) (122 . 229) (124 . 341)) ((83 . -201) (
+    92 . -201)) ((92 . -199)) ((90 . 337)) ((-1 . -225)) ((-1 . -220)) ((90 . 
+    336)) ((97 . -13) (-1 . -13)) ((84 . 333) (166 . 1) (165 . 2) (164 . 3) (
+    163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (
+    6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (
+    157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 
+    . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 
+    . 33) (168 . 34) (155 . 35) (85 . 243) (172 . 244) (144 . 334) (89 . 239) 
+    (91 . 240) (117 . 241) (118 . 242) (119 . 335)) ((84 . -237) (83 . -237)) 
+    ((83 . 331) (84 . 332)) ((-1 . -241)) ((59 . -243) (89 . -243) (91 . -243)
+    ) ((90 . 330)) ((59 . -245) (91 . -245) (89 . -245)) ((59 . -244) (91 . 
+    -244) (89 . -244)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161
+    . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 
+    . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77
+    . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 
+    . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 
+    . 35) (85 . 243) (172 . 244) (144 . 334) (89 . 239) (91 . 240) (117 . 241)
+    (118 . 242) (119 . 335) (84 . 371)) ((84 . -235) (83 . -235)) ((97 . -14)
+    (-1 . -14)) ((84 . -240) (83 . -240)) ((166 . 1) (165 . 2) (164 . 3) (163
+    . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 
+    . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157
+    . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 
+    26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 
+    33) (168 . 34) (155 . 35) (85 . 243) (172 . 244) (144 . 370)) ((-1 . -226)
+    ) ((-1 . -224)) ((-1 . -191)) ((92 . -205) (83 . -205)) ((92 . 368) (83 . 
+    369)) ((92 . 367)) ((25 . 81) (26 . 82) (27 . 83) (148 . 223) (125 . 366))
+    ((-1 . -184)) ((90 . 365) (-1 . -28)) ((90 . 364)) ((166 . 1) (165 . 2) (
+    164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) 
+    (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (
+    181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (81 . 25) (93
+    . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176
+    . 33) (168 . 34) (155 . 35) (172 . 360) (25 . 81) (26 . 82) (27 . 83) (
+    148 . 250) (90 . 361) (44 . 362) (80 . 363)) ((-1 . -218)) ((90 . 359)) ((
+    90 . 358)) ((-1 . -213)) ((-1 . -180)) ((48 . -162) (83 . -162)) ((48 . 
+    -160) (83 . -160)) ((95 . -303) (-1 . -303)) ((95 . -295) (-1 . -295)) ((
+    95 . -154) (-1 . -154)) ((-1 . -165)) ((-1 . -219)) ((-1 . -217)) ((90 . 
+    376)) ((-1 . -182)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (
+    161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (
+    159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20)
+    (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (
+    156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (
+    155 . 35) (172 . 375)) ((90 . 374) (-1 . -28)) ((-1 . -183)) ((-1 . -188))
+    ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8
     . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (
     179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (
     79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (
-    167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (85 . 243) 
-    (172 . 244) (144 . 370)) ((-1 . -226)) ((-1 . -224)) ((-1 . -191)) ((92 . 
-    -205) (83 . -205)) ((92 . 368) (83 . 369)) ((92 . 367)) ((25 . 81) (26 . 
-    82) (27 . 83) (148 . 223) (125 . 366)) ((-1 . -184)) ((90 . 365) (-1 . -28
-    )) ((90 . 364)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (162 . 5) (161 . 
-    6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7 . 13) (159 . 14
-    ) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (76 . 20) (77 . 
-    21) (78 . 22) (79 . 23) (81 . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29
-    ) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 . 
-    360) (25 . 81) (26 . 82) (27 . 83) (148 . 250) (90 . 361) (44 . 362) (80 
-    . 363)) ((-1 . -218)) ((90 . 359)) ((90 . 358)) ((-1 . -213)) ((-1 . -180)
-    ) ((48 . -162) (83 . -162)) ((48 . -160) (83 . -160)) ((95 . -303) (-1 . 
-    -303)) ((95 . -295) (-1 . -295)) ((95 . -154) (-1 . -154)) ((-1 . -165)) (
-    (-1 . -219)) ((-1 . -217)) ((90 . 376)) ((-1 . -182)) ((166 . 1) (165 . 2)
-    (164 . 3) (163 . 4) (162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10
-    ) (5 . 11) (6 . 12) (7 . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (
-    181 . 18) (157 . 19) (76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81
-    . 25) (93 . 26) (177 . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 
-    . 32) (176 . 33) (168 . 34) (155 . 35) (172 . 375)) ((90 . 374) (-1 . -28)
-    ) ((-1 . -183)) ((-1 . -188)) ((166 . 1) (165 . 2) (164 . 3) (163 . 4) (
-    162 . 5) (161 . 6) (160 . 7) (8 . 8) (3 . 9) (4 . 10) (5 . 11) (6 . 12) (7
-    . 13) (159 . 14) (158 . 15) (179 . 16) (180 . 17) (181 . 18) (157 . 19) (
-    76 . 20) (77 . 21) (78 . 22) (79 . 23) (80 . 24) (81 . 25) (93 . 26) (177 
-    . 27) (156 . 28) (82 . 29) (167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 
-    . 34) (155 . 35) (172 . 373) (25 . 81) (26 . 82) (27 . 83) (148 . 250)) ((
-    -1 . -189)) ((-1 . -190)) ((6 . 12) (7 . 13) (181 . 372)) ((84 . -239) (83
-    . -239)) ((84 . -236) (83 . -236)) ((92 . -206) (83 . -206)) ((90 . 378))
-    ((-1 . -187)) ((90 . 377)) ((-1 . -181)) ((-1 . -186)) ((-1 . -185))))
+    167 . 30) (86 . 31) (87 . 32) (176 . 33) (168 . 34) (155 . 35) (172 . 373)
+    (25 . 81) (26 . 82) (27 . 83) (148 . 250)) ((-1 . -189)) ((-1 . -190)) ((
+    6 . 12) (7 . 13) (181 . 372)) ((84 . -239) (83 . -239)) ((84 . -236) (83 
+    . -236)) ((92 . -206) (83 . -206)) ((90 . 378)) ((-1 . -187)) ((90 . 377))
+    ((-1 . -181)) ((-1 . -186)) ((-1 . -185))))
 
 (define c99x-rto-v
   #(#f 177 177 177 177 176 176 176 176 176 176 176 176 176 176 175 175 175 
index 270f676cd7fd98a9ea4ae6fd7852fbfbc32b4ef6..a4f1df078abdfbcb5afc26b8b55e4c3ded742439 100644 (file)
     . 24) (50 . 25)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7)
     (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 
     15) (41 . 16) (42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 . 22) 
-    (48 . 23) (49 . 24) (50 . 55) (36 . 56)) ((3 . 53) (7 . 54)) ((-1 . -43)) 
-    ((-1 . -42)) ((-1 . -41)) ((-1 . -38)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7
-    . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 
-    . 13) (39 . 52)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7)
-    (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 51)) ((3 
+    (48 . 23) (49 . 24) (50 . 55) (36 . 56)) ((3 . 53) (7 . 54)) ((35 . -43) (
+    -1 . -43)) ((35 . -42) (-1 . -42)) ((35 . -41) (-1 . -41)) ((35 . -38) (-1
+    . -38)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8)
+    (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 52)) ((3 . 1) (4 
+    . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (
+    16 . 11) (15 . 12) (38 . 13) (39 . 51)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (
+    7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38
+    . 13) (39 . 50)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7
+    ) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 49)) ((3 
     . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11
-    . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 50)) ((3 . 1) (4 . 2) (5 . 3) (
+    . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 48)) ((3 . 1) (4 . 2) (5 . 3) (
     6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 
-    . 12) (38 . 13) (39 . 49)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 
-    6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 
-    48)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10
-    . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 47)) ((9 . 45) (8 . 46
-    ) (-1 . -31)) ((-1 . -27)) ((14 . 42) (13 . 43) (12 . 44) (-1 . -24)) ((16
-    . 40) (15 . 41) (-1 . -21)) ((18 . 38) (17 . 39) (-1 . -16)) ((22 . 34) (
-    21 . 35) (20 . 36) (19 . 37) (-1 . -13)) ((24 . 32) (23 . 33) (-1 . -11)) 
-    ((25 . 31) (-1 . -9)) ((26 . 30) (-1 . -7)) ((27 . 29) (-1 . -5)) ((28 . 
-    28) (-1 . -3)) ((31 . 26) (29 . 27) (2 . -1) (1 . -1) (35 . -1)) ((35 . 0)
-    ) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 
-    9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (
-    42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 . 22) (48 . 23) (49 
-    . 78)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (
-    10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 
-    16) (42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 . 22) (48 . 77))
-    ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9
-    ) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (
-    42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 . 76)) ((3 . 1) (4 . 
-    2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16
-    . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 . 17) (43 . 
-    18) (44 . 19) (45 . 20) (46 . 75)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5
-    ) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13
-    ) (39 . 14) (40 . 15) (41 . 16) (42 . 17) (43 . 18) (44 . 19) (45 . 74)) (
-    (3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) 
-    (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 
-    . 17) (43 . 18) (44 . 73)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 
+    . 12) (38 . 13) (39 . 47)) ((9 . 45) (8 . 46) (35 . -31) (-1 . -31)) ((35 
+    . -27) (-1 . -27)) ((14 . 42) (13 . 43) (12 . 44) (35 . -24) (-1 . -24)) (
+    (16 . 40) (15 . 41) (35 . -21) (-1 . -21)) ((18 . 38) (17 . 39) (35 . -16)
+    (-1 . -16)) ((22 . 34) (21 . 35) (20 . 36) (19 . 37) (35 . -13) (-1 . -13
+    )) ((24 . 32) (23 . 33) (35 . -11) (-1 . -11)) ((25 . 31) (35 . -9) (-1 . 
+    -9)) ((26 . 30) (35 . -7) (-1 . -7)) ((27 . 29) (35 . -5) (-1 . -5)) ((28 
+    . 28) (35 . -3) (-1 . -3)) ((31 . 26) (29 . 27) (2 . -1) (1 . -1) (35 . -1
+    )) ((35 . 0)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9
+    . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15)
+    (41 . 16) (42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 . 22) (48
+    . 23) (49 . 78)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7
+    ) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 
+    . 15) (41 . 16) (42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 . 22
+    ) (48 . 77)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 
+    . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) 
+    (41 . 16) (42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 . 76)) ((3
+    . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (
+    11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 
+    . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 75)) ((3 . 1) (4 . 2) (5 . 3) (6
+    . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 
+    12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 . 17) (43 . 18) (44 . 19) 
+    (45 . 74)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 
+    8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (
+    41 . 16) (42 . 17) (43 . 18) (44 . 73)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (
+    7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38
+    . 13) (39 . 14) (40 . 15) (41 . 16) (42 . 17) (43 . 72)) ((3 . 1) (4 . 2)
+    (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 
+    . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 . 17) (43 . 71
+    )) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 
+    . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16)
+    (42 . 70)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 
+    . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) 
+    (41 . 16) (42 . 69)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 
+    . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (
+    40 . 15) (41 . 16) (42 . 68)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37
+    . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39
+    . 14) (40 . 15) (41 . 16) (42 . 67)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 
+    . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 
+    . 13) (39 . 14) (40 . 15) (41 . 66)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 
+    . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 
+    . 13) (39 . 14) (40 . 15) (41 . 65)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 
+    . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 
+    . 13) (39 . 14) (40 . 64)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 
     6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 
-    14) (40 . 15) (41 . 16) (42 . 17) (43 . 72)) ((3 . 1) (4 . 2) (5 . 3) (6 
+    14) (40 . 63)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (
+    9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 62)) ((3 . 1
+    ) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 
+    10) (16 . 11) (15 . 12) (38 . 13) (39 . 61)) ((3 . 1) (4 . 2) (5 . 3) (6 
     . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 
-    12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 . 17) (43 . 71)) ((3 . 1) 
-    (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10
-    ) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 . 70)) (
-    (3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) 
-    (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 
-    . 69)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (
-    10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 
-    16) (42 . 68)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (
-    9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15
-    ) (41 . 16) (42 . 67)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (
+    12) (38 . 13) (39 . 60)) ((35 . -39) (-1 . -39)) ((35 . -40) (-1 . -40)) (
+    (35 . -32) (-1 . -32)) ((35 . -33) (-1 . -33)) ((35 . -34) (-1 . -34)) ((
+    35 . -35) (-1 . -35)) ((35 . -36) (-1 . -36)) ((35 . -37) (-1 . -37)) ((7 
+    . 59)) ((35 . -45) (-1 . -45)) ((2 . -47) (1 . -47)) ((2 . 57) (1 . 58)) (
+    (35 . -46) (-1 . -46)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (
     8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) 
-    (40 . 15) (41 . 66)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 
-    . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (
-    40 . 15) (41 . 65)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 
-    . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (
-    40 . 64)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8
-    ) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 63)) ((
-    3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (
-    11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 62)) ((3 . 1) (4 . 2) (5 . 3)
-    (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15
-    . 12) (38 . 13) (39 . 61)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 
-    . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 
-    . 60)) ((-1 . -39)) ((-1 . -40)) ((-1 . -32)) ((-1 . -33)) ((-1 . -34)) ((
-    -1 . -35)) ((-1 . -36)) ((-1 . -37)) ((7 . 59)) ((-1 . -45)) ((2 . -47) (1
-    . -47)) ((2 . 57) (1 . 58)) ((-1 . -46)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4)
-    (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (15 . 12) (
-    38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 . 17) (43 . 18) (44 . 19) (45 
-    . 20) (46 . 21) (47 . 22) (48 . 23) (49 . 24) (50 . 81)) ((2 . 80)) ((-1 
-    . -30)) ((-1 . -29)) ((-1 . -28)) ((14 . 42) (13 . 43) (12 . 44) (-1 . -26
-    )) ((14 . 42) (13 . 43) (12 . 44) (-1 . -25)) ((16 . 40) (15 . 41) (-1 . 
-    -23)) ((16 . 40) (15 . 41) (-1 . -22)) ((18 . 38) (17 . 39) (-1 . -20)) ((
-    18 . 38) (17 . 39) (-1 . -19)) ((18 . 38) (17 . 39) (-1 . -18)) ((18 . 38)
-    (17 . 39) (-1 . -17)) ((22 . 34) (21 . 35) (20 . 36) (19 . 37) (-1 . -15)
-    ) ((22 . 34) (21 . 35) (20 . 36) (19 . 37) (-1 . -14)) ((24 . 32) (23 . 33
-    ) (-1 . -12)) ((25 . 31) (-1 . -10)) ((26 . 30) (-1 . -8)) ((27 . 29) (-1 
-    . -6)) ((28 . 28) (-1 . -4)) ((30 . 79) (29 . 27)) ((3 . 1) (4 . 2) (5 . 3
-    ) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (10 . 9) (11 . 10) (16 . 11) (
-    15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 16) (42 . 17) (43 . 18) (44 
-    . 19) (45 . 20) (46 . 21) (47 . 22) (48 . 23) (49 . 24) (50 . 82)) ((-1 . 
-    -44)) ((2 . -48) (1 . -48)) ((2 . -2) (1 . -2) (35 . -2))))
+    (40 . 15) (41 . 16) (42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 
+    . 22) (48 . 23) (49 . 24) (50 . 81)) ((2 . 80)) ((35 . -30) (-1 . -30)) ((
+    35 . -29) (-1 . -29)) ((35 . -28) (-1 . -28)) ((14 . 42) (13 . 43) (12 . 
+    44) (35 . -26) (-1 . -26)) ((14 . 42) (13 . 43) (12 . 44) (35 . -25) (-1 
+    . -25)) ((16 . 40) (15 . 41) (35 . -23) (-1 . -23)) ((16 . 40) (15 . 41) (
+    35 . -22) (-1 . -22)) ((18 . 38) (17 . 39) (35 . -20) (-1 . -20)) ((18 . 
+    38) (17 . 39) (35 . -19) (-1 . -19)) ((18 . 38) (17 . 39) (35 . -18) (-1 
+    . -18)) ((18 . 38) (17 . 39) (35 . -17) (-1 . -17)) ((22 . 34) (21 . 35) (
+    20 . 36) (19 . 37) (35 . -15) (-1 . -15)) ((22 . 34) (21 . 35) (20 . 36) (
+    19 . 37) (35 . -14) (-1 . -14)) ((24 . 32) (23 . 33) (35 . -12) (-1 . -12)
+    ) ((25 . 31) (35 . -10) (-1 . -10)) ((26 . 30) (35 . -8) (-1 . -8)) ((27 
+    . 29) (35 . -6) (-1 . -6)) ((28 . 28) (35 . -4) (-1 . -4)) ((30 . 79) (29 
+    . 27)) ((3 . 1) (4 . 2) (5 . 3) (6 . 4) (7 . 5) (37 . 6) (8 . 7) (9 . 8) (
+    10 . 9) (11 . 10) (16 . 11) (15 . 12) (38 . 13) (39 . 14) (40 . 15) (41 . 
+    16) (42 . 17) (43 . 18) (44 . 19) (45 . 20) (46 . 21) (47 . 22) (48 . 23) 
+    (49 . 24) (50 . 82)) ((35 . -44) (-1 . -44)) ((2 . -48) (1 . -48)) ((2 . 
+    -2) (1 . -2) (35 . -2))))
 
 (define cpp-rto-v
   #(#f 50 50 49 49 48 48 47 47 46 46 45 45 44 44 44 43 43 43 43 43 42 42 42 
index f20c1a046d435ef3633dc3365d6c47b512056102..7baa5d258a23948b4cc4d32d136932de0569d317 100644 (file)
   #:use-module ((srfi srfi-43) #:select (vector-map))
   )
 
-;; @item c99-spec
+;; @deffn {Variable} c99-spec
 ;; This variable is the specification a-list for the hacked ISO C99 language.
 ;; Run this through @code{make-lalr-machine} to get an a-list for the
 ;; automaton.  The grammar is modified to parse CPP statements and comments.
 ;; The output of the end parser will be a SXML tree (w/o the @code{*TOP*} node.
+;; @end deffn
 (define c99-spec
   (lalr-spec
    (notice (string-append "Copyright (C) 2016,2017 Matthew R. Wette"
     ;; non-terminal leaves
     (identifier
      ($ident ($$ `(ident ,$1)))
-     ('cpp-ident ($$ `(ident ,$1))))
+     ('cpp-ident ($$ `(ident ,$1)))
+     )
     (constant
      ($fixed ($$ `(fixed ,$1)))                ; integer-constant
      ($float ($$ `(float ,$1)))                ; floating-constant
 ;;; =====================================
 
 ;; The following are needed by the code in pbody.scm.
-(define c99-mach-len-v (assq-ref c99-mach 'len-v))
-(define c99-mach-pat-v (assq-ref c99-mach 'pat-v))
-(define c99-mach-rto-v (assq-ref c99-mach 'rto-v))
-(define c99-mach-mtab (assq-ref c99-mach 'mtab))
-(define c99-mach-act-v (vector-map
-                        (lambda (ix f) (eval f (current-module)))
-                        (vector-map (lambda (ix actn) (wrap-action actn))
-                                    (assq-ref c99-mach 'act-v))))
+(define c99-len-v (assq-ref c99-mach 'len-v))
+(define c99-pat-v (assq-ref c99-mach 'pat-v))
+(define c99-rto-v (assq-ref c99-mach 'rto-v))
+(define c99-mtab (assq-ref c99-mach 'mtab))
+(define c99-act-v (vector-map
+                  (lambda (ix f) (eval f (current-module)))
+                  (vector-map (lambda (ix actn) (wrap-action actn))
+                              (assq-ref c99-mach 'act-v))))
 
 (include-from-path "nyacc/lang/c99/body.scm")
 
-(define c99-mach-raw-parser (make-lalr-parser c99-mach))
+(define raw-parser (make-lalr-parser c99-mach))
 
-(define (c99-mach-run-parse)
+(define (run-parse)
   (let ((info (fluid-ref *info*)))
-    (c99-mach-raw-parser (gen-c-lexer) #:debug (cpi-debug info))))
+    (raw-parser (gen-c-lexer) #:debug (cpi-debug info))))
 
 (define* (dev-parse-c99 #:key
                        (cpp-defs '())  ; CPP defines
        (with-fluid*
           *info* info
           (lambda ()
-            (c99-mach-raw-parser (gen-c-lexer #:mode mode #:xdef? xdef?)
-                                  #:debug debug)))))
+            (raw-parser (gen-c-lexer #:mode mode #:xdef? xdef?)
+                        #:debug debug)))))
    (lambda (key fmt . rest)
      (report-error fmt rest)
      #f)))
 
 ;;; =====================================
 
-;; @item gen-c99-files [dir] => #t
+;; @deffn {Procedure} gen-c99-files [dir] => #t
 ;; Update or generate the files @quot{c99act.scm} and @quot{c99tab.scm}.
 ;; These are the tables and actions for the C99 parser.
 ;; If there are no changes to existing files, no update occurs.
+;; @end deffn
 (define (gen-c99-files . rest)
   (define (lang-dir path)
     (if (pair? rest) (string-append (car rest) "/" path) path))
   (define (xtra-dir path)
     (lang-dir (string-append "mach.d/" path)))
 
-  (write-lalr-actions c99-mach (xtra-dir "c99act.scm.new"))
-  (write-lalr-tables c99-mach (xtra-dir "c99tab.scm.new"))
+  (write-lalr-actions c99-mach (xtra-dir "c99act.scm.new") #:prefix "c99-")
+  (write-lalr-tables c99-mach (xtra-dir "c99tab.scm.new") #:prefix "c99-")
   (let ((a (move-if-changed (xtra-dir "c99act.scm.new")
                            (xtra-dir "c99act.scm")))
        (b (move-if-changed (xtra-dir "c99tab.scm.new")
                            (xtra-dir "c99tab.scm"))))
-    (when (or a b) 
-      (system (string-append "touch " (lang-dir "parser.scm"))))))
+    #;(when (or a b) 
+    (system (string-append "touch " (lang-dir "parser.scm"))))
+    (or a b)))
 
-;; @item gen-c99x-files [dir] => #t
+;; @deffn {Procedure} gen-c99x-files [dir] => #t
 ;; Update or generate the files @quot{c99xact.scm} and @quot{c99xtab.scm}.
 ;; These are the tables and actions for the C99 expression parser.
 ;; If there are no changes to existing files, no update occurs.
+;; @end deffn
 (define (gen-c99x-files . rest)
   (define (lang-dir path)
     (if (pair? rest) (string-append (car rest) "/" path) path))
         (cexpr-mach (compact-machine
                      (hashify-machine
                       (make-lalr-machine cexpr-spec)))))
-    (write-lalr-actions cexpr-mach (xtra-dir "c99xact.scm.new"))
-    (write-lalr-tables cexpr-mach (xtra-dir "c99xtab.scm.new")))
+    (write-lalr-actions cexpr-mach (xtra-dir "c99xact.scm.new")
+                       #:prefix "c99x-")
+    (write-lalr-tables cexpr-mach (xtra-dir "c99xtab.scm.new")
+                      #:prefix "c99x-"))
     
   (let ((a (move-if-changed (xtra-dir "c99xact.scm.new")
                            (xtra-dir "c99xact.scm")))
     (when (or a b) 
       (system (string-append "touch " (lang-dir "parser.scm")))
       #;(compile-file (lang-dir "xparser.scm"))
-      )))
+      )
+    (or a b)))
 
 ;; --- last line ---
index ade8b59d57b30dc349826d0edf5132eb33cd888f..9e1ba4c62baaf3b6f348906ebd87cb6e4435c28a 100644 (file)
   #:use-module (nyacc lang c99 cpp)
   )
 
-(cond-expand
- (guile-2)
- (guile
-  (use-modules (ice-9 syncase))
-  (use-modules (ice-9 optargs)))
- (mes))
-
 (include-from-path "nyacc/lang/c99/mach.d/c99tab.scm")
 (include-from-path "nyacc/lang/c99/body.scm")
 (include-from-path "nyacc/lang/c99/mach.d/c99act.scm")
 
 ;; Parse given a token generator.  Uses fluid @code{*info*}.
 ;; A little ugly wrt re-throw but
-(define c99-raw-parser
+(define raw-parser
   (let ((parser (make-lalr-parser
                     (list (cons 'len-v c99-len-v) (cons 'pat-v c99-pat-v)
                           (cons 'rto-v c99-rto-v) (cons 'mtab c99-mtab)
         (throw 'c99-error "C99 parse error"))))))
 
 ;; This is used to parse included files at top level.
-(define (c99-parser-run-parse)
+(define (run-parse)
   (let ((info (fluid-ref *info*)))
-    (c99-raw-parser (gen-c-lexer) #:debug (cpi-debug info))))
+    (raw-parser (gen-c-lexer #:mode 'decl) #:debug (cpi-debug info))))
 
 ;; @deffn {Procedure} parse-c99 [#:cpp-defs def-a-list] [#:inc-dirs dir-list] \
-;;               [#:mode ('code|'file)] [#:debug bool]
+;;               [#:mode ('code|'file|'decl)] [#:debug bool]
 ;; This needs to be explained in some detail.
 ;; tdd = typedef dict: (("<time>" time_t) ... ("<unistd.h>" ...))
 ;; Default mode is @code{'code}.
 ;;            #:inc-help (append '("myinc.h" "foo_t" "bar_t") c99-std-help)
 ;;            #:mode 'file))
 ;; @end example
+;; Note: for @code{file} mode user still needs to make sure CPP conditional
+;; expressions can be fully evaluated, which may mean adding compiler generated
+;; defines (e.g., using @code{gen-cpp-defs}).
 ;; @end deffn
 (define* (parse-c99 #:key
                    (cpp-defs '())      ; CPP defines
                    (inc-dirs '())      ; include dirs
                    (inc-help '())      ; include helpers
-                   (mode 'code)        ; mode: 'file or 'code
+                   (mode 'code)        ; mode: 'file, 'code or 'decl
                    (xdef? #f)          ; pred to determine expand
                    (debug #f))         ; debug
   (catch
@@ -86,8 +82,8 @@
        (with-fluid*
           *info* info
           (lambda ()
-            (c99-raw-parser (gen-c-lexer #:mode mode #:xdef? xdef?)
-                             #:debug debug)))))
+            (raw-parser (gen-c-lexer #:mode mode #:xdef? xdef?)
+                        #:debug debug)))))
    (lambda (key fmt . rest)
      (report-error fmt rest)
      #f)))
index 91e2612800a57210e18d24729b2183c6ca07fabb..5e986fa61b43d003dbed646d5d572c970bb90e5b 100644 (file)
@@ -1,6 +1,6 @@
 ;;; nyacc/lang/c99/pprint.scm
 ;;;
-;;; Copyright (C) 2015,2016 Matthew R. Wette
+;;; Copyright (C) 2015-2017 Matthew R. Wette
 ;;;
 ;;; This program is free software: you can redistribute it and/or modify
 ;;; it under the terms of the GNU General Public License as published by 
 
 (define protect-expr? (make-protect-expr op-prec op-assc))
 
-;; @deffn pretty-print-c99 tree [#:indent-level 2]
+;; @deffn pretty-print-c99 tree [port] [options]
 ;; Convert and print a C99 sxml tree to the current output port.
 ;; The optional keyword argument @code{#:indent-level} provides the
 ;; indent level, with default of 2.
-(define* (pretty-print-c99 tree #:key (indent-level 2) (ugly #f))
+;; @table code
+;; @item #:indent-level <level>
+;; indent level for C code
+;; @item #:per-line-prefix <string>
+;; string
+;; @item #:ugly #t|#f
+;; pring ugly
+;; @end table
+;; @end deffn
+(define* (pretty-print-c99 tree
+                          #:optional (port (current-output-port))
+                          #:key (indent-level 2) ugly per-line-prefix)
 
-  ;;(define fmtr (make-pp-formatter))
-  (define fmtr (if ugly (make-pp-formatter/ugly) (make-pp-formatter)))
+  (define fmtr
+    ((if ugly make-pp-formatter/ugly make-pp-formatter)
+     port #:per-line-prefix per-line-prefix))
   (define (push-il)(fmtr 'push))
   (define (pop-il) (fmtr 'pop))
 
     (sxml-match tree
       ;; sxml-match continues here to avoid stack overflow
       ;; |#
-      
+
+      ((udecl . ,rest)
+       (ppx `(decl . ,rest)))
       ((decl ,decl-spec-list)
        (ppx decl-spec-list) (sf ";\n"))
       ((decl ,decl-spec-list ,init-declr-list)
-       (ppx decl-spec-list) (ppx init-declr-list) (sf ";\n"))
+       (ppx decl-spec-list) (sf " ") (ppx init-declr-list) (sf ";\n"))
       ((decl ,decl-spec-list ,init-declr-list ,comment)
-       (ppx decl-spec-list) (ppx init-declr-list) (sf "; ") (ppx comment))
+       (ppx decl-spec-list) (sf " ")
+       (ppx init-declr-list) (sf "; ") (ppx comment))
       ((decl-no-newline ,decl-spec-list ,init-declr-list) ; for (int i = 0;
-       (ppx decl-spec-list) (ppx init-declr-list) (sf ";"))
+       (ppx decl-spec-list) (sf " ") (ppx init-declr-list) (sf ";"))
 
       ((comp-decl ,spec-qual-list ,declr-list)
        (ppx spec-qual-list) (ppx declr-list) (sf ";\n"))
        (ppx spec-qual-list) (ppx declr-list) (sf "; ") (ppx comment))
 
       ((decl-spec-list . ,dsl)
-       (let iter ((dsl dsl))
-        (when (pair? dsl)
-          (case (sx-tag (car dsl))
-            ((stor-spec) (sf "~A " (car (sx-ref (car dsl) 1))))
-            ((type-qual) (sf "~A " (sx-ref (car dsl) 1)))
-            ((type-spec) (ppx (car dsl)))
-            (else (sf "[?:~S] " (car dsl))))
-          ;;(if (pair? (cdr dsl)) (sf " "))
-          (iter (cdr dsl)))))
+       (pair-for-each
+       (lambda (dsl)
+         (case (sx-tag (car dsl))
+           ((stor-spec) (sf "~A" (car (sx-ref (car dsl) 1))))
+           ((type-qual) (sf "~A" (sx-ref (car dsl) 1)))
+           ((type-spec) (ppx (car dsl)))
+           (else (sf "[?:~S]" (car dsl))))
+         (if (pair? (cdr dsl)) (sf " ")))
+       dsl))
 
       ((init-declr-list . ,rest)
        (pair-for-each
        (lambda (pair)
-         (sf " ")
          (ppx (car pair))
-         (if (pair? (cdr pair)) (sf ",")))
+         (if (pair? (cdr pair)) (sf ", ")))
        rest))
       ((comp-declr-list . ,rest)
        (pair-for-each
        (lambda (pair)
-         (sf " ")
          (ppx (car pair))
-         (if (pair? (cdr pair)) (sf ",")))
+         (if (pair? (cdr pair)) (sf ", ")))
        rest))
 
       ((init-declr ,declr ,initr) (comp declr initr))
         ((union-def) (ppx arg))
         ((enum-def) (ppx arg))
         ((typename) (sf "~A" (sx-ref arg 1)))
-        ((void) (sf "void"))
+        ((void) (sf "void "))
         (else (error "missing " arg))))
 
       ((struct-ref (ident ,name)) (sf "struct ~A" name))
 
       ((enum-defn (ident ,name) (p-expr (fixed ,value)))
        (sf "~A = ~A,\n" name value))
+      ((enum-defn (ident ,name) (neg (p-expr (fixed ,value))))
+       (sf "~A = -~A,\n" name value))
       ((enum-defn (ident ,name))
        (sf "~A,\n" name))
 
              (declr (sx-ref tree 2))
              (compd-stmt (sx-ref tree 3)))
         (ppx decl-spec-list)
-        (sf " ")
         (ppx declr)
         (sf " ")
         (ppx compd-stmt)))
index f4bd6c518b8549860f32ecc533d6aa3c2baf3fcc..4aae667b1daadaa9a0714cc264cd0c38774fa2fc 100644 (file)
     ("wctype.h" "wctrans_t" "wctype_t" "wint_t")
     ))
 
-;; @deffn {Procedure} gen-gcc-defs args  [#:CC "clang"] => '(("ABC" . "123") ...)
+;; @deffn {Procedure} gen-gcc-defs args  [#:CC "clang"] => '("ABC=123" ...)
 ;; Generate a list of default defines produced by gcc (or clang).
 ;; @end deffn
 (define gen-gcc-defs
   ;; @code{"gcc -dM -E"} will generate lines like @code{"#define ABC 123"}.
   ;; We generate and return a list like @code{'(("ABC" . "123") ...)}.
-  (let ((rx (make-regexp "#define\\s+(\\S+)\\s+(.*)")))
-    (lambda* (args #:key (CC "gcc"))
+  (let ((rx1 (make-regexp "#define\\s+([A-Za-z0-9_]+\\([^)]*\\))\\s+(.*)"))
+       (rx2 (make-regexp "#define\\s+([A-Za-z0-9_]+)\\s+(.*)")))
+    (case-lambda*
+     ((args #:key (CC "gcc"))
       (map
        (lambda (l)
-        (let ((m (regexp-exec rx l)))
-          (cons (match:substring m 1) (match:substring m 2))))
+        ;; could use (string-delete #\space (match:substring m 1))
+        (let ((m (or (regexp-exec rx1 l) (regexp-exec rx2 l))))
+          (string-append (match:substring m 1) "=" (match:substring m 2))))
        (let ((ip (open-input-pipe (string-append CC " -dM -E - </dev/null"))))
         (let iter ((lines '()) (line (read-line ip 'trim)))
           (if (eof-object? line) lines
-              (iter (cons line lines) (read-line ip 'trim)))))))))
+              (iter (cons line lines) (read-line ip 'trim)))))))
+     ((#:key (CC "gcc")) (gen-gcc-defs '() #:CC CC)))))
 
 ;; @deffn {Procedure} remove-inc-trees tree
 ;; Remove the trees included with cpp-include statements.
index b61d0fbe67d86f84b7b41bad928f995eb4b24b14..5f414d08cbfa1d60b886b0510e93caa7c954010d 100644 (file)
@@ -1,4 +1,5 @@
 ;;; nyacc/lang/c99/util2.scm - C processing code
+;;; call this munge.scm ?
 ;;; 
 ;;; Copyright (C) 2015-2017 Matthew R. Wette
 ;;;
 
 ;; utilities for processing output trees
 
-;; The idea is to convert declarations into something like
-;; @example
-;; const char *args[21];  /* command arguments */
-;; @end example
-;; @noindent
-;; into
-;; @example
-;; ("args" (comment " command arguments ")
-;;  (array-of 21) (pointer-to) (fixed "char"))
-;; @end example
-;; @noindent
-;; or without the comment.  It is a question whether we need the fixed part.
-;; In addition, we want to reduce to a set of canonical types.  So something
-;; like @code{foo_t} should be expanded.
-
 ;; KEEPING STRUCTS ENUMS etc
 ;; if have typename and want to keep it, then change
 ;;   (typename "foo_t")
 ;;  (make-proxy comp-udecl) => udecl
 ;;  (revert-proxy udecl) => comp-udecl
 
+;; NOTE
+;;  stripdown no longer deals with typeref expansion
+;; use
+;;  expand-typerefs, then stripdown, then udecl->mspec
+
 (define-module (nyacc lang c99 util2)
-  #:export (tree->udict
-           stripdown stripdown-2
-           udecl->mspec
-           udecl->mspec/comm
+  #:export (c99-trans-unit->udict
+           c99-trans-unit->udict/deep
+
+           expand-typerefs
+           stripdown
+           udecl->mspec udecl->mspec/comm
 
            unwrap-decl
            canize-enum-def-list
-           fix-fields
            fixed-width-int-names
 
-           match-decl match-comp-decl match-param-decl
+           munge-decl munge-comp-decl munge-param-decl
            declr->ident
+
+           clean-field-list
+
+           ;; deprecated
+           tree->udict tree->udict/deep
+           match-decl match-comp-decl match-param-decl
            expand-decl-typerefs
+           fix-fields
+           ;; debuggins
+           stripdown-1 stripdown-2
            )
   #:use-module (nyacc lang c99 pprint)
-  #:use-module (ice-9 pretty-print)
-  #:use-module (srfi srfi-1)
+  #:use-module (nyacc lang util)
   #:use-module ((sxml fold) #:select (foldts foldts*))
   #:use-module (sxml match)
-  #:use-module (nyacc lang util)
+  #:use-module (srfi srfi-1)
+  #:use-module (srfi srfi-2)
+  ;;#:use-module (system base pmatch)
   #:use-module (nyacc lang c99 pprint)
+  #:use-module (ice-9 pretty-print)
   )
 
+(define tmap-fmt
+  '(("char" "%hhd")
+    ("unsigned char" "%hhu")
+    ("short int" "%hd")
+    ("unsigned short int" "%hu")
+    ("int" "%d")
+    ("unsigned int" "%u")
+    ("long int" "%ld")
+    ("unsigned long int" "%lu")
+    ("long long int" "%lld")
+    ("unsigned long long int" "%llu")))
+
 ;; Use the term @dfn{udecl}, or unit-declaration, for a declaration which has
 ;; only one decl-item.  That is where,
 ;; @example
 
 ;; may need to replace (typename "int32_t") with (fixed-type "int32_t")
 
-
 ;; @deffn {Procedure} declr->ident declr => (ident "name")
-;; just match the declarator
-;; (init-declr <declr> [<initzer>])
+;; Given a declarator, aka @code{init-declr}, return the identifier.
+;; This is used by @code{trans-unit->udict}.
 ;; See also: declr->id-name in body.scm.
 ;; @end deffn
 (define (declr->ident declr)
   (sxml-match declr
+    ((ident ,name) declr)
     ((init-declr ,declr . ,rest) (declr->ident declr))
     ((comp-declr ,declr) (declr->ident declr))
     ((param-declr ,declr) (declr->ident declr))
-    ((ident ,name) declr)
     ((array-of ,dir-declr ,array-spec) (declr->ident dir-declr))
     ((array-of ,dir-declr) (declr->ident dir-declr))
     ((ptr-declr ,pointer ,dir-declr) (declr->ident dir-declr))
     ((scope ,declr) (declr->ident declr))
     (,otherwise (throw 'util-error "c99/util2: unknown declarator: " declr))))
 
-;; @deffn {Procedure} unwrap-decl decl seed => seed
-;; This is a fold to break up multiple declarators.
-;; @example
-;; (decl (decl-spec-list ...) (init-declr-list (init-declr ...) ...))
-;; =>
-;; ((decl (decl-spec-list ...) (init-declr ...))
-;;  (decl (decl-spec-list ...) (init-declr ...))
-;;  ...)
-;; @end example
-;; @end deffn
-(define (unwrap-decl decl seed)
-  (cond
-   ((not (eqv? 'decl (car decl))) seed)
-   ((< (length decl) 3) seed)          ; this should catch struct-ref etc.
-   (else
-    (let* ((tag (sx-ref decl 0))
-          (attr (sx-attr decl))
-          (spec (sx-ref decl 1))       ; (decl-spec-list ...)
-          (id-l (sx-ref decl 2))       ; (init-declr-list ...)
-          (tail (sx-tail decl 3)))     ; comment
-      (let iter ((res seed) (idl (cdr id-l)))
-       (if (null? idl) res
-           (let* ((declr (sx-ref (car idl) 1))
-                  (ident (declr->ident declr))
-                  (name (cadr ident)))
-             (iter (cons (if attr
-                             (cons* tag attr spec (car idl) tail)
-                             (cons* tag spec (car idl) tail))
-                         res)
-                   (cdr idl)))))))))
-
-
-;; @deffn {Procedure} tree->udict tree => udict
-;; Turn a C parse tree into a assoc-list of names and definitions.
+;; @deffn {Procedure} c99-trans-unit->udict tree [seed] [#:filter f] => udict
+;; @deffnx {Procedure} c99-trans-unit->udict/deep tree [seed]=> udict
+;; Turn a C parse tree into a assoc-list of global names and definitions.
 ;; This will unwrap @code{init-declr-list} into list of decls w/
 ;; @code{init-declr}.
+;; @example
 ;; BUG: need to add struct and union defn's: struct foo { int x; };
 ;; how to deal with this
 ;; lookup '(struct . "foo"), "struct foo", ???
 ;; wanted "struct" -> dict but that is not great
-;; solution: match-decl => '(struct . "foo") then filter to generate
-;; ("struct" ("foo" . decl) ..)
-;; ("union" ("bar" . decl) ..)
+;; solution: munge-decl => '(struct . "foo") then filter to generate
+;; ("struct" ("foo" . decl) ("bar" . decl) ...)
+;; ("union" ("bar" . decl) ("bar" . decl) ...)
+;; ("enum" ("" . decl) ("foo" . decl) ("bar" . decl) ...)
+;; @end example
+;; So globals could be in udict, udefs or anon-enum.
+;; @example
+;; What about anonymous enums?  And enums in general?
+;; Anonmous enum should be expaneded into 
+;; @end example
 ;; @end deffn
-(define (tree->udict tree)
+;; @noindent
+;; If @var{tree} is not a pair then @var{seed} -- or @code{'()} -- is returned.
+;; The filter @var{f} is either @code{#t}, @code{#f} or predicate procedure
+;; of one argument, the include path, to indicate whether it should be included
+;; in the dictionary.
+(define* (c99-trans-unit->udict tree #:optional (seed '()) #:key filter)
+  (define (inc-keeper? tree)
+    (if (and (eqv? (sx-tag tree) 'cpp-stmt)
+            (eqv? (sx-tag (sx-ref tree 1)) 'include))
+       (if (procedure? filter)
+           (filter (let ((arg (sx-ref (sx-ref tree 1) 1)))
+                     (substring arg 1 (1- (string-length arg)))))
+           filter)
+       #f))
   (if (pair? tree)
-      (fold match-decl '() (cdr tree))
-      '()))
-
-;; @deffn {Procedure} match-decl decl seed
-;; This procedure is intended to be used with @code{fold}.  It breaks up
-;; up the init-declr-list into individual init-declr items and associates
-;; with the identifier being declared.  So this is a fold iterator to
-;; provide a dictionary of declared names.
+      (fold
+       (lambda (tree seed)
+        (cond
+         ((eqv? (sx-tag tree) 'decl)
+          (munge-decl tree seed))
+         ((inc-keeper? tree)
+          (c99-trans-unit->udict (sx-ref tree 1) seed #:filter filter))
+         (else seed)))
+       seed
+       (cdr tree))
+      seed))
+(define (c99-trans-unit->udict/deep tree)
+  (c99-trans-unit->udict tree #:filter #t))
+(define tree->udict c99-trans-unit->udict)
+(define tree->udict/deep c99-trans-unit->udict/deep)
+
+;; @deffn {Procedure} munge-decl decl seed [#:expand-enums #f] => seed
+;; This is a fold iterator to used by @code{tree->udict}.  It converts the
+;; multiple @code{init-declr} items in an @code{init-declr-list} of a
+;; @code{decl} into an a-list of multiple pairs of name and @code{udecl}
+;; trees with a single @code{init-declr} and no @code{init-declr-list}.
+;; That is, a @code{decl} of the form
 ;; @example
-;; (decl (decl-spec-list ...) (init-declr-list (init-declr ...) ...))
+;; (decl (decl-spec-list ...)
+;;       (init-declr-list (init-declr (... "a")) (init-declr (... "b")) ...))
 ;; @end example
 ;; @noindent
-;; has been replaced by
+;; is munged into list with elements
 ;; @example
-;; (decl (decl-spec-list ...) (init-declr ...))
-;; (decl (decl-spec-list ...) ...)
+;; ("a" . (udecl (decl-spec-list ...) (init-declr (... "a"))))
+;; ("b" . (udecl (decl-spec-list ...) (init-declr (... "b"))))
 ;; @end example
-;; Here we generate a dictionary of all declared items:
+;; The @code{/deep} version will plunge into cpp-includes.
+;; Here we generate a dictionary of all declared items in a file:
 ;; @example
 ;; (let* ((sx0 (with-input-from-file src-file parse-c))
 ;;       (sx1 (merge-inc-trees! sx0))
 ;;       (name-dict (fold match-decl-1 '() (cdr sx1))))
 ;; @end example
-;; TODO: add enums because they are global!!
-;; turn enum { ABC = 123 }; into '(ABC . (enum .. "ABC" "123" .. )
+;; TODO: add enums because they are global!!, but this should be user opt
+;; @example
+;; enum { ABC = 123 }; => ???
+;; @end example
+;; Unexpanded, unnamed enums have keys @code{"enum"}.
+;; Enum, struct and union def's have keys @code{(enum . "name")},
+;; @code{(struct . "name")} and @code{(union . "name)}, respectively.
+;; See @code{udict-struct-ref}, @code{udict-union-ref}, @code{udict-enum-ref}
+;; and @code{udict-ref}.
 ;; @end deffn
-(define (match-decl decl seed)
-  (let* ((tag (sx-ref decl 0)) (attr (sx-attr decl)))
-    (case tag
-      ((decl)
-       (let* ((spec (sx-ref decl 1))   ; (decl-spec-list ...)
-             (tbd (sx-ref decl 2)))    ; (init-declr-list ...) OR ...
-        (cond
-         ((or (not tbd) (eqv? 'comment (sx-tag tbd)))
-          ;; no init-declr-list => struct or union def or param-decl enum
-          ;;(display "spec:\n") (pretty-print decl)
-          (sxml-match spec
-            ((decl-spec-list
-              (type-spec
-               (struct-def (ident ,name) . ,rest2) . ,rest1))
-             (acons `(struct . ,name) decl seed))
-            ((decl-spec-list
-              (type-spec
-               (union-def (ident ,name) . ,rest2) . ,rest1))
-             (acons `(union . ,name) decl seed))
-            ((decl-spec-list
-              (type-spec
-               (enum-def
-                (enum-def-list
-                 (enum-defn
-                  (ident "ABC")
-                  (p-expr (fixed "123")))))))
-             ;; TODO
-             seed)
-            (,otherwise
-             ;; e.g., enum { VAL = 1 };
-             ;;(simple-format #t "+++ otherwise: ~S\n" tbd) (pretty-print decl)
-             seed)))
-         (else ;; decl with init-declr-list
-          (let* ((id-l tbd) (tail (sx-tail decl 3)))
-            (let iter ((res seed) (idl (cdr id-l)))
-              (if (null? idl) res
-                  (let* ((declr (sx-ref (car idl) 1))
-                         (ident (declr->ident declr))
-                         (name (cadr ident)))
-                    (iter
-                     (acons name
-                            (if attr
-                                (cons* tag attr spec (car idl) tail)
-                                (cons* tag spec (car idl) tail))
-                            res)
-                     (cdr idl))))))))))
-      (else seed))))
-
-;; @deffn {Procedure} match-comp-decl decl seed
+
+;; TODO:
+;; enum tag => "enum" (tag . udecl)
+;; enum { NAME } => "enum" ("" . udecl) ???? WHAT TO DO ????
+;; need (ud-lookup name) (ud-lookup-struct name) (ud-lookup-union name)
+;; USING ud-udict-struct-ref 
+(define* (munge-decl decl seed #:key (expand-enums #f))
+
+  (define (iter-declrs init-declr-l tail seed)
+    (if (not init-declr-l) seed
+       (let iter ((seed seed) (idl (cdr init-declr-l)))
+         (if (null? idl) seed
+             (let* ((tag 'udecl) (attr (sx-attr decl))
+                    (specl (sx-ref decl 1)) (declr (sx-ref (car idl) 1))
+                    (ident (declr->ident declr)) (name (cadr ident)))
+               (iter
+                (acons name (sx-cons* tag attr specl (car idl) tail) seed)
+                (cdr idl)))))))
+
+  ;;(simple-format #t "munge-decl ~S\n" decl)
+  (cond
+   ((not (pair? decl)) seed)
+   ((eqv? (sx-tag decl) 'decl)
+    (let* ((tag (sx-tag decl)) (tag 'udecl)
+          (attr (sx-attr decl))
+          (spec (sx-ref decl 1))       ; (decl-spec-list ...)
+          (sx2 (sx-ref decl 2)) ; (init-declr-list ...) OR ...
+          (init-d-l (if (and sx2 (eqv? (sx-tag sx2) 'init-declr-list)) sx2 #f))
+          (tail (sx-tail decl (if init-d-l 3 2))))
+      (sxml-match spec
+       ((decl-spec-list
+         (type-spec (struct-def (ident ,name) . ,rest2) . ,rest1))
+        (acons `(struct . ,name) decl (iter-declrs init-d-l tail seed)))
+       ((decl-spec-list
+         (type-spec (struct-def . ,rest2) . ,rest1))
+        (acons `(struct . "*anon*") decl (iter-declrs init-d-l tail seed)))
+       ((decl-spec-list
+         (type-spec (union-def (ident ,name) . ,rest2) . ,rest1))
+        (acons `(union . ,name) decl (iter-declrs init-d-l tail seed)))
+       ((decl-spec-list
+         (type-spec (union-def . ,rest2) . ,rest1))
+        (acons `(union . "*anon*") decl (iter-declrs init-d-l tail seed)))
+       ((decl-spec-list
+         (type-spec (enum-def (ident ,name) . ,rest2) . ,rest1))
+        (acons `(enum . ,name) decl (iter-declrs init-d-l tail seed)))
+       ((decl-spec-list
+         (type-spec (enum-def . ,rest2) . ,rest1))
+        (acons `(enum . "*anon*") decl (iter-declrs init-d-l tail seed)))
+       (,otherwise
+        (iter-declrs init-d-l tail seed)))))
+   ((eqv? (sx-tag decl) 'comp-decl)
+    (munge-comp-decl decl seed #:expand-enums expand-enums))
+   ((eqv? (sx-tag decl) 'param-decl)
+    (munge-param-decl decl seed #:expand-enums expand-enums))
+   (else seed)))
+
+;; @deffn {Procedure} munge-comp-decl decl seed [#:expand-enums #f]
 ;; This will turn
 ;; @example
 ;; (comp-decl (decl-spec-list (type-spec "int"))
 ;; This is coded to be used with fold-right in order to preserve order
 ;; in @code{struct} and @code{union} field lists.
 ;; @end deffn
-(define (match-comp-decl decl seed)
+(define* (munge-comp-decl decl seed #:key (expand-enums #f))
   (if (not (eqv? 'comp-decl (car decl))) seed
       (let* ((tag (sx-ref decl 0))
             (attr (sx-attr decl))
             (spec (sx-ref decl 1))     ; (type-spec ...)
             (id-l (sx-ref decl 2))     ; (init-declr-list ...)
             (tail (sx-tail decl 3)))   ; opt comment, different here
-       ;;(simple-format #t "1: ~S\n" id-l)
        (let iter ((res seed) (idl (cdr id-l)))
          (if (null? idl) res
              (let* ((declr (sx-ref (car idl) 1))
                     (ident (declr->ident declr))
                     (name (cadr ident)))
-               ;;(pretty-print `(comp-decl ,spec ,(car idl) . ,tail))
                (acons name
                       (if attr
                           (cons* tag attr spec (car idl) tail)
                           (cons* tag spec (car idl) tail))
                       (iter res (cdr idl)))))))))
+(define match-comp-decl munge-comp-decl)
 
-;; @deffn {Procedure} match-param-decl param-decl seed
+;; @deffn {Procedure} match-param-decl param-decl seed [#:expand-enums #f]
 ;; This will turn
 ;; @example
-;; (param-decl (decl-spec-list (type-spec "int")) (param-declr (ident "a")))
+;; (param-decl (decl-spec-list (type-spec "int"))
+;;             (param-declr (ident "a")))
 ;; @end example
 ;; @noindent
 ;; into
 ;; This is coded to be used with fold-right in order to preserve order
 ;; in @code{struct} and @code{union} field lists.
 ;; @end deffn
-(define (match-param-decl decl seed)
+(define* (munge-param-decl decl seed #:key (expand-enums #f))
   (if (not (eqv? 'param-decl (car decl))) seed
       (let* ((tag (sx-ref decl 0))
             (attr (sx-attr decl))
             (ident (declr->ident declr))
             (name (cadr ident)))
        (acons name decl seed))))
+(define match-param-decl munge-param-decl)
        
-;; @deffn find-special udecl-alist seed => ..
-;; NOT DONE
-;; @example
-;; '((struct . ("foo" ...) ...)
-;;   (union . ("bar" ...) ...)
-;;   (enum . ("bar" ...) ...)
-;;   seed)
-;; @end example
+;; like member but returns first non-declr of type in dict
+(define (non-declr type udict)
+  (let iter ((dict udict))
+    (cond
+     ((null? dict) #f)
+     ((and (pair? (car dict)) (eqv? type (caar dict))) dict)
+     (else (iter (cdr dict))))))
+     
+;; @deffn {Procedure} udict-ref name
+;; @deffnx {Procedure} udict-struct-ref name
+;; @deffnx {Procedure} udict-union-ref name
+;; @deffnx {Procedure} udict-enum-ref name
+;; @end deffn
+(define (udict-ref udict name)
+  (or (assoc-ref udict name)
+      (let iter ((dict (non-declr 'enum udict)))
+       (cond
+        ((not dict) #f)
+        ((assoc-ref (cdar dict) name))
+        (else (iter (non-declr 'enum dict)))))))
+(define (udict-struct-ref udict name)
+  #f)
+(define (udict-union-ref udict name)
+  #f)
+(define (udict-enum-ref udict name)
+  #f)
+
+;; @deffn {Variable} fixed-width-int-names
+;; This is a list of standard integer names (e.g., @code{"uint8_t"}).
 ;; @end deffn
-(define (find-special udecl-alist seed)
-  (let iter ((struct '()) (union '()) (enum '()) (udal udecl-alist))
-    (if (null? udal) (cons* (cons 'struct struct)
-                         (cons 'union union)
-                         (cons 'enum enum)
-                         seed)
-       '())))
-
-(define tmap-fmt
-  '(("char" "%hhd")
-    ("unsigned char" "%hhu")
-    ("short int" "%hd")
-    ("unsigned short int" "%hu")
-    ("int" "%d")
-    ("unsigned int" "%u")
-    ("long int" "%ld")
-    ("unsigned long int" "%lu")
-    ("long long int" "%lld")
-    ("unsigned long long int" "%llu")))
-
 (define fixed-width-int-names
   '("int8_t" "uint8_t" "int16_t" "uint16_t"
     "int32_t" "uint32_t" "int64_t" "uint64_t"))
           (else (cons item seed))))
    '() decl-spec-list))
 
-;; @deffn {Procedure} expand-decl-typerefs udecl udecl-dict => udecl
-;; Given a declaration or component-declaration, expand all typename,
-;; struct, union and enum refs.
+;; @deffn {Procedure} expand-typerefs udecl udecl-dict [#:keep '()]
+;; Given a declaration or component-declaration, return a udecl with all
+;; typenames (not in @var{keep}), struct, union and enum refs expanded.
+;; (but enums to int?)
 ;; @example
 ;; typedef const int  (*foo_t)(int a, double b);
 ;; extern    foo_t    fctns[2];
 ;; =>
 ;; extern const int  (*fctns[2])(int a, double b);
 ;; @end example
-;; @noindent
-;; Cool. Eh? (but is it done?)
 ;; @end deffn
-(define* (expand-decl-typerefs udecl udecl-dict #:key (keep '()))
-  ;;(display "FIXME: some decls have no init-declr-list\n")
-  ;; between adding (init-declr-list) to those or having predicate
-  ;; (has-init-declr? decl)
+(define* (expand-typerefs udecl udecl-dict #:key (keep '()))
+  ;; ??? add (init-declr-list) OR having predicate (has-init-declr? decl)
   (let* ((tag (sx-tag udecl))          ; decl or comp-decl
         (attr (sx-attr udecl))         ; (@ ...)
         (specl (sx-ref udecl 1))       ; decl-spec-list
-        (declr (or (sx-find 'init-declr udecl)
-                   (sx-find 'comp-declr udecl)))
+        (declr (or (sx-find 'init-declr udecl) ; declarator
+                   (sx-find 'comp-declr udecl)
+                   (sx-find 'param-declr udecl)))
         (tail (if declr (sx-tail udecl 3) (sx-tail udecl 2))) ; opt comment
         (tspec (cadr (sx-find 'type-spec specl))))
-    ;;(simple-format #t "=D> ~S\n" decl-spec-list)
-    ;;(simple-format #t "init-declr: ~S\n" init-declr)
     (case (car tspec)
       ((typename)
        (cond
       ((struct-ref union-ref)
        (simple-format (current-error-port)
                      "+++ c99/util2: struct/union-ref: more to do?\n")
-       ;;(simple-format #t "\nstruct-ref:\n") (pretty-print udecl)
+       (simple-format #t "\nstruct-ref:\n") (pretty-print udecl)
+       (let* ((is-struct (eqv? 'struct-ref (car tspec)))
+             (ident (cadr tspec))
+             (name (cadr ident))
+             (ref (if is-struct
+                      (udict-struct-ref udecl-dict name)
+                      (udict-union-ref udecl-dict name)))
+             )
+        #f)
        udecl)
 
       ((struct-def union-def)
        (simple-format (current-error-port) "chack: enum-ref NOT DONE\n")
        udecl)
 
-      (else udecl))))
+      (else
+       udecl))))
+(define expand-decl-typerefs expand-typerefs)
+
+;; === enum handling ...
   
 ;; @deffn {Procedure} canize-enum-def-list
 ;; Fill in constants for all entries of an enum list.
          (iter (cons (append (car edl) `((p-expr (fixed ,is1)))) rez)
                ix1 (cdr edl))))))))
 
-;; @deffn stripdown udecl decl-dict => decl
+;; @deffn {Procecure} enum-ref enum-def-list name => string
+;; Gets value of enum where @var{enum-def-list} looks like
+;; @example
+;; (enum-def-list (enum-defn (ident "ABC") (p-expr (fixed "123")) ...))
+;; @end example
+;; so that
+;; @example
+;; (enum-def-list edl "ABC") => "123"
+;; @end example
+(define (enum-ref enum-def-list name)
+  (let iter ((el (cdr (canize-enum-def-list enum-def-list))))
+    (cond
+     ((null? el) #f)
+     ((not (eqv? 'enum-defn (caar el))) (iter (cdr el)))
+     ((string=? name (cadr (cadar el))) (cadadr (caddar el)))
+     (else (iter (cdr el))))))
+
+;; @deffn {Procedure} gen-enum-udecl nstr vstr => (udecl ...)
+;; @example
+;; (gen-enum-udecl "ABC" "123")
+;; =>
+;; (udecl (decl-spec-list
+;;         (type-spec
+;;          (enum-def
+;;           (enum-def-list
+;;            (enum-defn (ident "ABC") (p-expr (fixed "123")))))))))
+;; @end example
+;; @end deffn
+(define (gen-enum-udecl nstr vstr)
+  `(udecl (decl-spec-list
+          (type-spec
+           (enum-def
+             (enum-def-list
+             (enum-defn (ident ,nstr) (p-expr (fixed ,vstr)))))))))
+
+;; === enum handling ...
+
+;;@deffn {Procedure} stripdown-1 udecl decl-dict [options]=> decl
+;; This is deprecated.
 ;; 1) remove stor-spec
 ;; 2) expand typenames
 ;; @example
 ;; (spec (typename x_t)) (init-declr (array-of 10 (ident a)))
 ;; (spec (typedef) (fixed-type "int")) (init-declr (pointer) (ident "x_t"))
 ;; =>
-;; [TO BE DOCUMENTED]
+;; (udecl (decl-spec-list (type-spec ...) ... (type-qual "const"))
+;;        (init-declr (ptr-declr (pointer ...)
 ;; @end example
 ;; @end deffn
-(define* (stripdown udecl decl-dict #:key (keep '()))
+(define* (stripdown-1 udecl decl-dict #:key (keep '()))
 
   ;;(define strip-list '(stor-spec type-qual comment))
   (define strip-list '(stor-spec type-qual))
     '())
 
   (define (fsU seed kseed tree)
-    (if (memq (car tree) strip-list)
-       seed
-       (if (null? seed)
-           (reverse kseed)
-           (cons (reverse kseed) seed))))
+    (cond
+     ((eqv? (sx-tag tree) 'stor-spec) seed)
+     ((eqv? (sx-tag tree) 'type-qual) seed)
+     ((null? seed) (reverse kseed))
+     (else (cons (reverse kseed) seed))))
        
   (define (fsH seed tree)
     (cons tree seed))
         (specl1 (foldts fsD fsU fsH '() specl)))
     (list tag specl1 declr)))
 
-;; This one experimental for guile ffi.
-(define* (stripdown-2 udecl decl-dict #:key (keep '()))
+(define* (stripdown-declr declr #:key const-ptr)
+  (define (fD seed tree) '())
 
-  ;;(define strip-list '(stor-spec type-qual comment))
-  (define strip-list '(stor-spec type-qual))
-
-  (define (fsD seed tree)
-    '())
-
-  (define (fsU seed kseed tree)
-    (if (memq (car tree) strip-list)
-       seed
-       (if (null? seed)
-           (reverse kseed)
-           (cons (reverse kseed) seed))))
+  (define (fU seed kseed tree)
+    (cond
+     ((null? seed) (reverse kseed))
+     ((eqv? (sx-tag tree) 'stor-spec) seed)
+     ((eqv? (sx-tag tree) 'type-qual)
+      (if (and const-ptr (string=? (sx-ref tree 1) "const"))
+         (cons (reverse kseed) seed)
+         seed))
+     (else (cons (reverse kseed) seed))))
        
-  (define (fsH seed tree)
+  (define (fH seed tree)
     (cons tree seed))
+   
+  (foldts fD fU fH '() declr))
 
-  (let* ((speclt (sx-tail udecl 1)))   ; decl-spec-list tail
-    ;; don't expand typedefs, structure specs etc,
-    (cond
-     ((and (eqv? 'stor-spec (caar speclt))
-          (eqv? 'typedef (cadar speclt)))
-      udecl)
-     ;; lone struct ref
-     (else
-      (let* ((xdecl (expand-decl-typerefs udecl decl-dict #:keep keep))
-            (tag (sx-tag xdecl))
-            (attr (sx-attr xdecl))
-            (specl (sx-ref xdecl 1))
-            (declr (sx-ref xdecl 2))
-            (specl1 (foldts fsD fsU fsH '() specl)))
-       (list tag specl1 declr))))
-      ))
-
-
-;; @deffn {Procedure} udecl->mspec sudecl
-;; Turn a stripped-down unit-declaration into an m-spec.
-;; This assumes decls have been run through @code{stripdown}.
+;; @deffn {Procedure} stripdown udecl decl-dict [options]=> decl
+;; 1) remove stor-spec
+;; @example
+;; =>
+;; @end example
 ;; @end deffn
-(define (udecl->mspec decl . rest)
+(define* (stripdown udecl decl-dict #:key const-ptr)
+  (let* (;;(speclt (sx-tail udecl))    ; decl-spec-list tail
+        (xdecl udecl)
+        (tag (sx-tag xdecl))
+        (attr (sx-attr xdecl))
+        (specl (sx-ref xdecl 1))
+        (declr (sx-ref xdecl 2))
+        (s-declr (stripdown-declr declr))
+        (is-ptr? (declr-is-ptr? declr))
+        ;;
+        (s-tag (sx-tag specl))
+        (s-attr (sx-attr specl))
+        (s-tail (strip-decl-spec-tail
+                 (sx-tail specl) #:keep-const? (and #:const-ptr is-ptr?)))
+        (specl (sx-cons* s-tag s-attr s-tail)))
+    ;;(pretty-print declr)
+    ;;(pretty-print s-declr)
+    (sx-list tag attr specl s-declr)))
+
+(define (declr-is-ptr? declr)
+  (and
+   (pair? (cdr declr))
+   (eqv? 'ptr-declr (caadr declr))))
+    
+(define* (strip-decl-spec-tail dsl-tail #:key keep-const?)
+  ;;(simple-format #t "spec=tail: ~S\n" dsl-tail)
+  (let iter ((dsl1 '()) (const-seen? #f) (tail dsl-tail))
+    (if (null? tail)
+       (reverse (if (and const-seen? keep-const?)
+                    (cons '(type-qual "const") dsl1)
+                    dsl1))
+       (case (caar tail)
+         ((type-qual)
+          (if (string=? (cadar tail) "const")
+              (iter dsl1 #t (cdr tail))
+              (iter dsl1 const-seen? (cdr tail))))
+         ((stor-spec)
+          (iter dsl1 const-seen? (cdr tail)))
+         (else
+          (iter (cons (car tail) dsl1) const-seen? (cdr tail)))))))
+
+;; @deffn {Procedure} udecl->mspec udecl
+;; @deffnx {Procedure} udecl->mspec/comm udecl [#:def-comm ""]
+;; Turn a stripped-down unit-declaration into an m-spec.  The second version
+;; include a comment. This assumes decls have been run through
+;; @code{stripdown}.
+;; @example
+;; (decl (decl-spec-list (type-spec "double"))
+;;       (init-declr-list (
+;;       (comment "state vector")
+;; =>
+;; ("x" "state vector" (array-of 10) (float "double")
+;; @end example
+;; @end deffn
+(define (udecl->mspec decl)
 
   (define (cnvt-array-size size-spec)
     (with-output-to-string (lambda () (pretty-print-c99 size-spec))))
 
   (define (unwrap-specl specl)
-    (let ((tspec (cadadr specl)))
-      ;;(simple-format #t "tspec:\n") (pretty-print tspec)
-      (sxml-match tspec
-       ((xxx-struct-def (field-list . ,rest))
-        `(struct-def ,@rest))
-       (,otherwise
-        tspec))))
+    (and=> (assq-ref (sx-tail specl) 'type-spec) car))
+   ;;?   (sxml-match tspec
+   ;;?    ((xxx-struct-def (field-list . ,rest))
     
-  (define (unwrap-declr declr)
+  (define* (unwrap-declr declr #:key (const #f))
+    ;;(simple-format #t "#:const=~S (car declr)=~S\n" const (car declr))
     (sxml-match declr
       ((ident ,name)
        (list name))
       ((init-declr ,item)
-       (unwrap-declr item))
-      ((comp-declr ,item)
-       (unwrap-declr item))
+       (unwrap-declr item #:const const))
       ((ptr-declr (pointer . ,r) ,dir-declr)
-       (cons '(pointer-to) (unwrap-declr dir-declr)))
+       (if const
+          (cons* '(const) '(pointer-to) (unwrap-declr dir-declr))
+          (cons '(pointer-to) (unwrap-declr dir-declr))))
       ((array-of ,dir-declr ,size)
        (cons `(array-of ,(cnvt-array-size size)) (unwrap-declr dir-declr)))
       ((ftn-declr ,dir-declr ,params)
        (cons '(function-returning) (unwrap-declr dir-declr)))
       ((scope ,expr)
        (unwrap-declr expr))
+      ((comp-declr ,item) (unwrap-declr item))
+      ((param-declr ,item) (unwrap-declr item))
       (,otherwise
        (simple-format #t "unwrap-declr: OTHERWISE\n") (pretty-print otherwise)
        ;; failed got: (array-of (ident "foo")) FROM const char foo[];
+       (error "udecl->mspec failed")
        #f)))
 
   (define (find-type-spec decl-spec-list)
       (if (eqv? 'type-spec (caar tsl)) (car tsl)
          (iter (cdr tsl))))) 
   
-  (let* ((decl-dict (if (pair? rest) (car rest) '()))
+  (let* (;;(decl-dict (if (pair? rest) (car rest) '()))
         (specl (sx-ref decl 1))
-        (declr (sx-ref decl 2))
+        (tspec (cadr specl))           ; type-spec
+        (const (and=> (sx-ref specl 2) ; const pointer ???
+                      (lambda (sx) (equal? (sx-ref sx 1) "const"))))
+        (declr (or (sx-ref decl 2) ;; param-decl -- e.g., f(void)
+                   '(ident "@arg")))
         (comm (sx-ref decl 3))
         (m-specl (unwrap-specl specl))
-        (m-declr (unwrap-declr declr))
+        (m-declr (unwrap-declr declr #:const const))
         (m-decl (reverse (cons m-specl m-declr))))
     m-decl))
 
-;; @deffn {Procedure} udecl->mspec/comm decl [dict] [#:def-comm ""]
-;; Convert declaration tree to an mspec
-;; @example
-;; (decl ... (comment "state vector")
-;; =>
-;; ("x" "state vector" (array-of 10) (float "double")
-;; @end example
-;; @end deffn
-(define* (udecl->mspec/comm decl #:optional (dict '()) #:key (def-comm ""))
+(define* (udecl->mspec/comm decl #:key (def-comm ""))
   (let* ((comm (or (and=> (sx-ref decl 3) cadr) def-comm))
-        (spec (udecl->mspec decl dict)))
+        (spec (udecl->mspec decl)))
     (cons* (car spec) comm (cdr spec))))
 
-;; @deffn {Procedure} fix-fields flds => flds
-;; This will take a list of fields from a struct and remove lone comments.
+;; @deffn {Procedure} clean-field-list field-list => flds
+;; Process the tagged field-list element of a struct and remove lone comments.
 ;; If a field following a lone comment has no code-comment, the lone comment
 ;; will be used.  For example,
 ;; @example
 ;; @end example
 ;; @noindent
 ;; @end deffn
-(define (fix-fields flds)
-  (let iter ((rz '()) (cl '()) (fl flds))
+(define (clean-field-list fld-list)
+  (let iter ((rz '()) (cl '()) (fl (cdr fld-list)))
     ;;(pretty-print fl)
     (cond
-     ((null? fl) (reverse rz))
+     ((null? fl) (cons 'field-list (reverse rz)))
      ((eqv? 'comment (caar fl))
       (iter rz (cons (cadar fl) cl) (cdr fl)))
      ((eqv? 'comp-decl (caar fl))
      (else
       (error "bad field")))))
 
+(define (fix-fields flds)
+  (cdr (clean-field-list `(field-list . ,flds))))
+
+;; ===== not used? ====================
+
+;;.@deffn {Procedure} unwrap-decl decl seed => seed
+;; This is a fold to break up multiple declarators.
+;; @example
+;; (decl (decl-spec-list ...) (init-declr-list (init-declr ...) ...))
+;; =>
+;; ((decl (decl-spec-list ...) (init-declr ...))
+;;  (decl (decl-spec-list ...) (init-declr ...))
+;;  ...)
+;; @end example
+;; @end deffn
+(define (unwrap-decl decl seed)
+  (cond
+   ((not (eqv? 'decl (car decl))) seed)
+   ((< (length decl) 3) seed)          ; this should catch struct-ref etc.
+   (else
+    (let* ((tag (sx-ref decl 0))
+          (attr (sx-attr decl))
+          (spec (sx-ref decl 1))       ; (decl-spec-list ...)
+          (id-l (sx-ref decl 2))       ; (init-declr-list ...)
+          (tail (sx-tail decl 3)))     ; comment
+      (let iter ((res seed) (idl (cdr id-l)))
+       (if (null? idl) res
+           (let* ((declr (sx-ref (car idl) 1))
+                  (ident (declr->ident declr))
+                  (name (cadr ident)))
+             (iter (cons (if attr
+                             (cons* tag attr spec (car idl) tail)
+                             (cons* tag spec (car idl) tail))
+                         res)
+                   (cdr idl)))))))))
+
+
 ;; --- last line ---
index 72ea1623848ec9dca32174b570e88ac3a1a12188..6f361c1dbc65bd8d70396e4360294ecbee7cef50 100644 (file)
   )
 
 (include-from-path "nyacc/lang/c99/mach.d/c99xtab.scm")
+(define c99-mtab c99x-mtab)
 (include-from-path "nyacc/lang/c99/body.scm")
 (include-from-path "nyacc/lang/c99/mach.d/c99xact.scm")
 
 ;; Parse given a token generator.  Uses fluid @code{*info*}.
-(define c99x-raw-parser
+(define raw-parser
   (let ((parser (make-lalr-parser 
                 (list (cons 'len-v c99x-len-v) (cons 'pat-v c99x-pat-v)
                       (cons 'rto-v c99x-rto-v) (cons 'mtab c99x-mtab)
@@ -46,9 +47,9 @@
         (pop-input)                    ; not sure this is right
         (throw 'c99-error "C99 parse error"))))))
 
-(define (c99x-run-parse)
+(define (run-parse)
   (let ((info (fluid-ref *info*)))
-    (c99x-raw-parser (gen-c-lexer) #:debug (cpi-debug info))))
+    (raw-parser (gen-c-lexer #:mode 'decl) #:debug (cpi-debug info))))
 
 ;; @item {Procedure} parse-c99x [#:cpp-defs defs] [#:debug bool]
 ;; This needs to be explained in some detail.
@@ -70,8 +71,8 @@
           (with-fluid*
               *info* info
               (lambda ()
-                (c99x-raw-parser (gen-c-lexer #:mode 'code #:xdef? xdef?)
-                                  #:debug debug)))))
+                (raw-parser (gen-c-lexer #:mode 'code #:xdef? xdef?)
+                            #:debug debug)))))
        (lambda (key fmt . rest)
         (report-error fmt rest)
         #f)))))
index db0dff1892b975c6ab6868434d0c29ab897ca2e0..f91114263a29a58ac421be3797a2480e789c864b 100644 (file)
@@ -14,9 +14,9 @@
            push-input pop-input reset-input-stack
            make-tl tl->list ;; rename?? to tl->sx for sxml-expr
            tl-append tl-insert tl-extend tl+attr
-           sx-tag
-           sx-attr sx-attr-ref sx-has-attr? sx-set-attr! sx-set-attr*
-           sx-ref sx-tail sx-find
+           sx-tag sx-attr sx-tail sx-ref sx-cons* sx-list
+           sx-attr-ref sx-has-attr? sx-set-attr! sx-set-attr*
+           sx-find
            ;; for pretty-printing
            make-protect-expr make-pp-formatter make-pp-formatter/ugly
            ;; for ???
   #:use-module ((srfi srfi-1) #:select(find))
   )
 
-(cond-expand
- (guile-2)
- (guile
-  (use-modules (ice-9 optargs))
-  (use-modules (ice-9 syncase)))
- (mes))
-
 ;; This is a generic copyright/licence that will be printed in the output
 ;; of the examples/nyacc/lang/*/ actions.scm and tables.scm files.
 (define lang-crn-lic "
@@ -85,19 +78,21 @@ the file COPYING included with the this distribution.")
 
 ;; @table code
 
-;; @deffn make-tl tag [item item ...]
+;; @deffn {Procedure} make-tl tag [item item ...]
 ;; Create a tagged-list structure.
+;; @end deffn
 (define (make-tl tag . rest)
   (let iter ((tail tag) (l rest))
     (if (null? l) (cons '() tail)
        (iter (cons (car l) tail) (cdr l)))))
 
-;; @deffn tl->list tl
+;; @deffn {Procedure} tl->list tl
 ;; Convert a tagged list structure to a list.  This collects added attributes
 ;; and puts them right after the (leading) tag, resulting in something like
 ;; @example
 ;; (<tag> (@ <attr>) <rest>)
 ;; @end example
+;; @end deffn
 (define (tl->list tl)
   (let ((heda (car tl))
        (head (let iter ((head '()) (attr '()) (tl-head (car tl)))
@@ -113,40 +108,46 @@ the file COPYING included with the this distribution.")
          (iter (cons (car tl-tail) tail) (cdr tl-tail))
          (cons tl-tail (append head tail))))))
 
-;; @deffn tl-insert tl item
+;; @deffn {Procedure} tl-insert tl item
 ;; Insert item at front of tagged list (but after tag).
+;; @end deffn
 (define (tl-insert tl item)
   (cons (cons item (car tl)) (cdr tl)))
 
-;; @deffn tl-append tl item ...
+;; @deffn {Procedure} tl-append tl item ...
 ;; Append items at end of tagged list.
+;; @end deffn
 (define (tl-append tl . rest)
   (cons (car tl)
        (let iter ((tail (cdr tl)) (items rest))
          (if (null? items) tail
              (iter (cons (car items) tail) (cdr items))))))
 
-;; @deffn tl-extend tl item-l
+;; @deffn {Procedure} tl-extend tl item-l
 ;; Extend with a list of items.
+;; @end deffn
 (define (tl-extend tl item-l)
   (apply tl-append tl item-l))
 
-;; @deffn tl-extend! tl item-l
+;; @deffn {Procedure} tl-extend! tl item-l
 ;; Extend with a list of items.  Uses @code{set-cdr!}.
+;; @end deffn
 (define (tl-extend! tl item-l)
   (set-cdr! (last-pair tl) item-l)
   tl)
 
-;; @deffn tl+attr tl key val)
+;; @deffn {Procedure} tl+attr tl key val)
 ;; Add an attribute to a tagged list.  Return the tl.
 ;; @example
 ;; (tl+attr tl 'type "int")
 ;; @end example
+;; @end deffn
 (define (tl+attr tl key val)
   (tl-insert tl (cons '@ (list key val))))
 
-;; @deffn tl-merge tl tl1
+;; @deffn {Procedure} tl-merge tl tl1
 ;; Merge guts of phony-tl @code{tl1} into @code{tl}.
+;; @end deffn
 (define (tl-merge tl tl1)
   (error "not implemented (yet)")
   )
@@ -158,13 +159,14 @@ the file COPYING included with the this distribution.")
 ;; attributea are `invisible'. For example, @code{'(elt (@abc) "d")}
 ;; is an sx of length two: the tag @code{elt} and the payload @code{"d"}.
 
-;; @deffn sx-ref sx ix => item
+;; @deffn {Procedure} sx-ref sx ix => item
 ;; Reference the @code{ix}-th element of the list, not counting the optional
 ;; attributes item.  If the list is shorter than the index, return @code{#f}.
 ;; @example
 ;; (sx-ref '(abc "def") 1) => "def"
 ;; (sx-ref '(abc (@ (foo "1")) "def") 1) => "def"
 ;; @end example
+;; @end deffn
 (define (sx-ref sx ix)
   (define (list-xref l x) (if (> (length l) x) (list-ref l x) #f))
   (cond
@@ -174,26 +176,52 @@ the file COPYING included with the this distribution.")
    (else
     (list-xref sx ix))))
 
-;; @deffn sx-tag sx => tag
+;; @deffn {Procedure} sx-tag sx => tag
 ;; Return the tag for a tree
+;; @end deffn
 (define (sx-tag sx)
   (if (pair? sx) (car sx) #f))
 
-;; @deffn sx-tail sx ix => (list)
-;; Return the tail starting at the ix-th cdr, starting from 0.
-;; For example, if sx has 3 items then (sx-tail sx 2) returns '().
-(define (sx-tail sx ix)
+;; @deffn {Procedure} sx-cons* tag (attr|#f)? ... => sx
+;; @deffnx {Procedure} sx-list tag (attr|#f)? ... => sx
+;; Generate the tag and the attr list if it exists.  Note that
+;; @end deffn
+(define (sx-cons* tag . rest)
+  (cond
+   ((null? rest) (list tag))
+   ((not (car rest)) (apply cons* tag (cdr rest)))
+   (else (apply cons* tag rest))))
+(define (sx-list tag . rest)
   (cond
-   ((zero? ix) (error "sx-tail: expecting index greater than 0"))
-   ((and (pair? (cadr sx)) (eqv? '@ (caadr sx))) (list-tail sx (1+ ix)))
-   (else (list-tail sx ix))))
+   ((null? rest) (list tag))
+   ((not (car rest)) (apply list tag (cdr rest)))
+   (else (apply list tag rest))))
+
+;; @deffn {Procedure} sx-tail sx [ix] => (list)
+;; Return the ix-th tail starting after the tag and attribut list, where
+;; @var{ix} must be positive.  For example,
+;; @example
+;; (sx-tail '(tag (@ (abc . "123")) (foo) (bar)) 1) => ((foo) (bar))
+;; @end example
+;; Without second argument @var{ix} is 1.
+;; @end deffn
+(define sx-tail
+  (case-lambda
+   ((sx ix)
+    (cond
+     ((zero? ix) (error "sx-tail: expecting index greater than 0"))
+     ((and (pair? (cadr sx)) (eqv? '@ (caadr sx))) (list-tail sx (1+ ix)))
+     (else (list-tail sx ix))))
+   ((sx)
+    (sx-tail sx 1))))
 
-;; @deffn sx-has-attr? sx
+;; @deffn {Procedure} sx-has-attr? sx
 ;; p to determine if @arg{sx} has attributes.
+;; @end deffn
 (define (sx-has-attr? sx)
   (and (pair? (cdr sx)) (pair? (cadr sx)) (eqv? '@ (caadr sx))))
 
-;; @deffn sx-attr sx => '(@ ...)|#f
+;; @deffn {Procedure} sx-attr sx => '(@ ...)|#f
 ;; @example
 ;; (sx-attr '(abc (@ (foo "1")) def) 1) => '(@ (foo "1"))
 ;; @end example
@@ -201,6 +229,7 @@ the file COPYING included with the this distribution.")
 ;; @example
 ;; (sx-attr sx) => '((a . 1) (b . 2) ...)
 ;; @end example
+;; @end deffn
 (define (sx-attr sx)
   (if (and (pair? (cdr sx)) (pair? (cadr sx)))
       (if (eqv? '@ (caadr sx))
@@ -208,16 +237,18 @@ the file COPYING included with the this distribution.")
          #f)
       #f))
 
-;; @deffn sx-attr-ref sx key => val
+;; @deffn {Procedure} sx-attr-ref sx key => val
 ;; Return an attribute value given the key, or @code{#f}.
+;; @end deffn
 (define (sx-attr-ref sx key)
   (and=> (sx-attr sx)
         (lambda (attr)
           (and=> (assq-ref (cdr attr) key) car))))
 
-;; @deffn sx-set-attr! sx key val
+;; @deffn {Procedure} sx-set-attr! sx key val
 ;; Set attribute for sx.  If no attributes exist, if key does not exist,
 ;; add it, if it does exist, replace it.
+;; @end deffn
 (define (sx-set-attr! sx key val . rest)
   (if (sx-has-attr? sx)
       (let ((attr (cadr sx)))
@@ -226,8 +257,8 @@ the file COPYING included with the this distribution.")
   sx)
 
 ;; @deffn sx-set-attr* sx key val [key val [key ... ]]
-;; Set attribute for sx.  If no attributes exist, if key does not exist,
-;; add it, if it does exist, replace it.
+;; Generate sx with added or changed attributes.
+;; @end deffn
 (define (sx-set-attr* sx . rest)
   (let iter ((attr (or (and=> (sx-attr sx) cdr) '())) (kvl rest))
     (cond
@@ -236,6 +267,7 @@ the file COPYING included with the this distribution.")
 
 ;; @deffn sx-find tag sx => ((tag ...) (tag ...))
 ;; Find the first matching element (in the first level).
+;; @end deffn
 (define (sx-find tag sx)
   (find (lambda (node)
          (and (pair? node) (eqv? tag (car node))))
@@ -244,7 +276,7 @@ the file COPYING included with the this distribution.")
 ;;; === pp ==========================
 ;; @section Pretty-Print and Other Utility Procedures
 
-;; @deffn make-protect-expr op-prec op-assc => side op expr => #t|#f
+;; @deffn {Procedure} make-protect-expr op-prec op-assc => side op expr => #t|#f
 ;; Generate procedure @code{protect-expr} for pretty-printers, which takes
 ;; the form @code{(protect-expr? side op expr)} and where @code{side}
 ;; is @code{'lval} or @code{'rval}, @code{op} is the operator and @code{expr}
@@ -255,6 +287,7 @@ the file COPYING included with the this distribution.")
 ;; @example
 ;; (protect-expr? 'left '+ '(mul ...)) => TBD
 ;; @end example
+;; @end deffn
 (define (make-protect-expr op-prec op-assc)
 
   (define (assc-lt? op)
@@ -263,9 +296,10 @@ the file COPYING included with the this distribution.")
   (define (assc-rt? op)
     (memq op (assq-ref op-assc 'right)))
 
-  ;; @deffn prec a b => '>|'<|'=|#f
+  ;; @deffn {Procedure} prec a b => '>|'<|'=|#f
   ;; Returns the prececence relation of @code{a}, @code{b} as
   ;; @code{<}, @code{>}, @code{=} or @code{#f} (no relation).
+  ;; @end deffn
   (define (prec a b)
     (let iter ((ag #f) (bg #f) (opg op-prec)) ;; a-group, b-group
       (cond
@@ -292,15 +326,18 @@ the file COPYING included with the this distribution.")
        ((=) (assc? op))
        (else #f)))))
 
-;; @deffn make-pp-formatter => fmtr
+;; @deffn {Procedure} make-pp-formatter [port] [#:per-line-prefix ""] => fmtr
 ;; @example
 ;; (fmtr 'push) ;; push indent level
 ;; (fmtr 'pop)  ;; pop indent level
 ;; (fmtr "fmt" arg1 arg2 ...)
 ;; @end example
-(define* (make-pp-formatter)
+;; @end deffn
+(define* (make-pp-formatter #:optional (port (current-output-port))
+                           #:key per-line-prefix)
   (letrec
-      ((maxcol 78)
+      ((maxcol (- 78 (if per-line-prefix (string-length per-line-prefix) 0)))
+       ;;(maxcol 78)
        (maxind 36)
        (column 0)
        (ind-lev 0)
@@ -319,6 +356,14 @@ the file COPYING included with the this distribution.")
        (lambda ()
          (set! ind-lev (max 0 (1- ind-lev)))
          (set! ind-len (* 2 ind-lev))))
+
+       (inc-column!
+       (lambda (inc)
+         (set! column (+ column inc))))
+
+       (set-column!
+       (lambda (val)
+         (set! column val)))
        
        (sf
        (lambda (fmt . args)
@@ -326,13 +371,16 @@ the file COPYING included with the this distribution.")
                 (len (string-length str)))
            (cond
             ((zero? column)
-             (display (ind-str))
-             (set! column (+ column ind-len)))
+             (if per-line-prefix (display per-line-prefix port))
+             (display (ind-str) port)
+             (inc-column! ind-len))
             ((> (+ column len) maxcol)
-             (newline)
-             (display (cnt-str))
-             (set! column (+ column ind-len 4))))
-           (display str)
+             (newline port)
+             (if per-line-prefix (display per-line-prefix port))
+             (display (cnt-str) port)
+             (set-column! (+ ind-len 4))))
+           (display str port)
+           (inc-column! len)
            (when (and (positive? len)
                       (eqv? #\newline (string-ref str (1- len))))
              (set! column 0))))))
@@ -348,10 +396,11 @@ the file COPYING included with the this distribution.")
        (else (error "pp-formatter: bad args"))
        ))))
 
-;; @deffn make-pp-formatter/ugly => fmtr
+;; @deffn {Procedure} make-pp-formatter/ugly => fmtr
 ;; Makes a @code{fmtr} like @code{make-pp-formatter} but no indentation
 ;; and just adds strings on ...
 ;; This is specific to C/C++ because it will newline if #\# seen first.
+;; @end deffn
 (define* (make-pp-formatter/ugly)
   (let*
       ((maxcol 78)
@@ -390,8 +439,9 @@ the file COPYING included with the this distribution.")
        ((eqv? 'pop arg0) #f)
        (else (error "pp-formatter/ugly: bad args"))))))
   
-;; @deffn move-if-changed src-file dst-file [sav-file]
+;; @deffn {Procedure} move-if-changed src-file dst-file [sav-file]
 ;; Return @code{#t} if changed.
+;; @end deffn
 (define (move-if-changed src-file dst-file . rest)
 
   (define (doit)
index bedfd5fef96d6f6f1aad4f20cbad7af8cd4da73a..f6481ed82fa48e3c73fc36189e1264eaebf1b2c7 100644 (file)
   #:use-module (ice-9 pretty-print)
   )
 
-(cond-expand
- (guile-2)
- (guile
-  (use-modules (ice-9 syncase))
-  (use-modules (ice-9 optargs)))
- (mes))
-
 ;; @section Constructing Lexical Analyzers
 ;; The @code{lex} module provides a set of procedures to build lexical
 ;; analyzers.  The approach is to first build a set of @defn{readers} for 
@@ -92,7 +85,7 @@
 
 (define (lsr chl) (list->string (reverse chl))) ; used often
 
-;; @deffn eval-reader reader string => result
+;; @deffn {Procedure} eval-reader reader string => result
 ;; For test and debug, this procedure will evaluate a reader on a string.
 ;; A reader is a procedure that accepts a single character argument intended
 ;; to match a specific character sequence.  A reader will read more characters
 ;; will pushback all characters read via @code{read-char} and return @code{#f}.
 ;; If it succeeds the input pointer will be at the position following the
 ;; last matched character.
+;; @end deffn
 (define (eval-reader reader string)
   (with-input-from-string string
     (lambda () (reader (read-char)))))
 
-;; @deffn make-space-skipper chset => proc
+;; @deffn {Procedure} make-space-skipper chset => proc
 ;; This routine will generate a reader to skip whitespace.
+;; @end deffn
 (define (make-space-skipper chset)
   (lambda (ch)
     (if (char-set-contains? chset ch)
            #t)))
        #f)))
         
-;; @deffn skip-c-space ch => #f|#t
+;; @deffn {Procedure} skip-c-space ch => #f|#t
 ;; If @code{ch} is space, skip all spaces, then return @code{#t}, else
 ;; return @code{#f}.
+;; @end deffn
 (define skip-c-space (make-space-skipper c:ws))
 
 
-;; @deffn make-ident-reader cs-first cs-rest => ch -> #f|string
+;; @deffn {Procedure} make-ident-reader cs-first cs-rest => ch -> #f|string
 ;; For identifiers, given the char-set for first character and the char-set
 ;; for following characters, return a return a reader for identifiers.
 ;; The reader takes a character as input and returns @code{#f} or @code{string}.
+;; This will generate exception on @code{#<eof>}.
+;; @end deffn
 (define (make-ident-reader cs-first cs-rest)
   (lambda (ch)
     (if (char-set-contains? cs-first ch)
                 (lsr chl))))
        #f)))
 
-;; @deffn read-c-ident ch => #f|string
+;; @deffn {Procedure} read-c-ident ch => #f|string
 ;; If ident pointer at following char, else (if #f) ch still last-read.
+;; @end deffn
 (define read-c-ident (make-ident-reader c:if c:ir))
 
-;; @deffn make-ident-like-p ident-reader
+;; @deffn {Procedure} make-ident-like-p ident-reader
 ;; Generate a predicate, from a reader, that determines if a string qualifies
 ;; as an identifier.
+;; @end deffn
 (define (make-like-ident-p reader)
   (lambda (s) (and (string? s) (eval-reader reader s))))
 (define make-ident-like-p make-like-ident-p)
 (define like-c-ident? (make-like-ident-p read-c-ident))
 
 
-;; @deffn make-string-reader delim
+;; @deffn {Procedure} make-string-reader delim
 ;; Generate a reader that uses @code{delim} as delimiter for strings.
 ;; TODO: need to handle matlab-type strings.
 ;; TODO: need to handle multiple delim's (like python)
+;; @end deffn
 (define (make-string-reader delim) ;; #:xxx
   (lambda (ch)
     (if (eq? ch delim)
                (else (iter (cons ch cl) (read-char)))))
        #f)))
 
-;; @deffn read-oct ch => "0123"|#f
+;; @deffn {Procedure} read-oct ch => "0123"|#f
 ;; Read octal number.
+;; @end deffn
 (define read-oct
   (let ((cs:oct (string->char-set "01234567")))
     (lambda (ch)
          (unread-char ch)
          cv))))))
 
-;; @deffn read-hex ch => "0x7f"|#f
+;; @deffn {Procedure} read-hex ch => "0x7f"|#f
 ;; Read octal number.
+;; @end deffn
 (define read-hex
   (let ((cs:dig (string->char-set "0123456789"))
        (cs:uhx (string->char-set "ABCDEF"))
          (iter (+ (* 16 cv) (- (char->integer ch) 87)) (read-char) (1+ n)))
         (else (unread-char ch) cv))))))
        
-;; @deffn read-c-string ch => ($string . "foo")
+;; @deffn {Procedure} read-c-string ch => ($string . "foo")
 ;; Read a C-code string.  Output to code is @code{write} not @code{display}.
-;; Return #f if @var{ch} is not @code{"}.
+;; Return #f if @var{ch} is not @code{"}. @*
+;; TODO: parse trigraphs
+;; ??=->#, ??/->\, ??'->^, ??(->[, ??)->], ??~->|, ??<->{, ??>->}, ??-->~
+;; and digraphs <:->[, :>->], <%->{ %>->} %:->#
+;; @end deffn
 (define (read-c-string ch)
   (if (not (eq? ch #\")) #f
       (let iter ((cl '()) (ch (read-char)))
 
 (define (fix-dot l) (if (char=? #\. (car l)) (cons #\0 l) l))
 
-;; @deffn make-num-reader => (proc ch) => #f|($fixed . "1")|($float . "1.0")
+;; @deffn {Procedure} make-num-reader => (proc ch) => #f|($fixed . "1")|($float . "1.0")
 ;; Reads C numbers.
 ;; This routine will clean by adding "0" before or after dot.
 ;; may want to replace "eEdD" w/ "e"
 ;; integer decimal(#t/#f) fraction exponent looking-at
 ;; i, f and e are lists of characters
+;; @end deffn
 (define (make-num-reader)
   ;; 0: start; 1: p-i; 2: p-f; 3: p-e-sign; 4: p-e-d; 5: packup
   ;; Removed support for leading '.' to be a number.
         (unless (eof-object? ch) (unread-char ch))
         (cons ty (lsr chl)))))))
 
-;; @deffn cnumstr->scm C99-str => scm-str
+;; @deffn {Procedure} cnumstr->scm C99-str => scm-str
 ;; Convert C number-string (e.g, @code{0x123LL}) to Scheme numbers-string
 ;; (e.g., @code{#x123}).
+;; @end deffn
 (define (cnumstr->scm str)
   (define (2- n) (1- (1- n)))
   (let* ((nd (string-length str)))
                    (trim-rt 0)))
            (trim-rt 0)))))
   
-;; @deffn read-c-num ch => #f|string
+;; @deffn {Procedure} read-c-num ch => #f|string
 ;; Reader for unsigned numbers as used in C (or close to it).
+;; @end deffn
 (define read-c-num (make-num-reader))
 
-;;.@deffn si-map string-list ix => a-list
+;;.@deffn {Procedure} si-map string-list ix => a-list
 ;; Convert list of strings to alist of char at ix and strings.
 ;; This is a helper for make-tree.
+;; @end deffn
 (define (si-map string-list ix)
   (let iter ((sal '()) (sl string-list))
     (cond
       (iter (cons (cons (string-ref (car sl) ix) (list (car sl))) sal)
             (cdr sl))))))
 
-;;.@deffn make-tree strtab -> tree
+;;.@deffn {Procedure} make-tree strtab -> tree
 ;; This routine takes an alist of strings and symbols and makes a tree
 ;; that parses one char at a time and provide @code{'else} entry for
 ;; signaling sequence found.  That is, if @code{("ab" . 1)} is an entry
 ;; then a chseq-reader (see below) would stop at @code{"ab"} and
 ;; return @code{1}.
+;; @end deffn
 (define (make-tree strtab)
   (define (si-cnvt string-list ix)
     (map (lambda (pair)
         (si-map string-list ix)))
   (si-cnvt (map car strtab) 0))
 
-;; @deffn make-chseq-reader strtab
+;; @deffn {Procedure} make-chseq-reader strtab
 ;; Given alist of pairs (string, token) return a function that eats chars
 ;; until (token . string) is returned or @code{#f} if no match is found.
+;; @end deffn
 (define (make-chseq-reader strtab)
   ;; This code works on the assumption that the else-part is always last
   ;; in the list of transitions.
              (pushback (cdr cl))))
          #f))))))
 
-;; @deffn make-comm-reader comm-table [#:eat-newline #t] => \
+;; @deffn {Procedure} make-comm-reader comm-table [#:eat-newline #t] => \
 ;;   ch bol -> ('$code-comm "..")|('$lone-comm "..")|#f
 ;; comm-table is list of cons for (start . end) comment.
 ;; e.g. ("--" . "\n") ("/*" . "*/")
 ;; If @code{eat-newline} is specified as true then for read comments 
 ;; ending with a newline a newline swallowed with the comment.
 ;; Note: assumes backslash is never part of the end
+;; @end deffn
 (define* (make-comm-reader comm-table #:key (eat-newline #f))
 
-  (define (mc-read-char)
+  (define (mc-read-char) ;; CHECK THIS
     (let ((ch (read-char)))
       (if (eqv? ch #\\)
          (let ((ch (read-char)))
               ((eq? px (string-length ps))
                (if (and (not eat-newline) (eq? #\newline (car sl)))
                    (unread-char #\newline))
-               (if (and (pair? cl) (eqv? (car cl) #\return)) ;; rem trailing \r 
-                   (cons tval (list->string (reverse (cdr cl))))
-                   (cons tval (list->string (reverse cl)))))
+               (if (and (pair? cl) (eqv? (car cl) #\cr)) ;; rem trailing \r 
+                   (cons tval (lsr (cdr cl)))
+                   (cons tval (lsr cl))))
               ((null? il) (find-end cl sl (cons (mc-read-char) il) ps px))
-              ((eof-object? (car il)) (error "open comment"))
+              ;;((eof-object? (car il)) (error "open comment" cl))
+              ((eof-object? (car il))
+               (if (char=? (string-ref ps px) #\newline) (lsr cl)
+                   (throw 'nyacc-error "open comment")))
               ((eqv? (car il) (string-ref ps px))
                (find-end cl (cons (car il) sl) (cdr il) ps (1+ px)))
               (else
                (let ((il1 (append-reverse sl il)))
                  (find-end (cons (car il1) cl) '() (cdr il1) ps 0)))))))
-       (let ((ep (match-beg (list ch) tree)))
+       (let ((ep (match-beg (list ch) tree))) ;; ep == end pattern?
          (if ep (find-end '() '() (list (mc-read-char)) ep 0) #f))))))
 
 (define read-c-comm (make-comm-reader '(("/*" . "*/") ("//" . "\n"))))
 
-;; @deffn filter-mt p? al => al
+;; @deffn {Procedure} filter-mt p? al => al
 ;; Filter match-table based on cars of al.
+;; @end deffn
 (define (filter-mt p? al) (filter (lambda (x) (p? (car x))) al))
 
-;; @deffn remove-mt p? al => al
+;; @deffn {Procedure} remove-mt p? al => al
 ;; Remove match-table based on cars of al.
+;; @end deffn
 (define (remove-mt p? al) (remove (lambda (x) (p? (car x))) al))
 
-;; @deffn map-mt f al => al
+;; @deffn {Procedure} map-mt f al => al
 ;; Map cars of al.
+;; @end deffn
 (define (map-mt f al) (map (lambda (x) (cons (f (car x)) (cdr x))) al))
 
-;; @deffn make-lexer-generator match-table => lexer-generator
+;; @deffn {Procedure} make-lexer-generator match-table => lexer-generator
 ;; @example
 ;; (define gen-lexer (make-lexer-generator #:ident-reader my-id-rdr))
 ;; (with-input-from-file "foo" (parse (gen-lexer)))
 ;; @end enumerate
 ;; todo: add bol status
 ;; todo: maybe separate reading of keywords from identifiers: (keywd ch) =>
+;; @end deffn
 (define* (make-lexer-generator match-table
                               #:key ident-reader num-reader
                               string-reader chlit-reader
index 6a92a18245dc1bf67ecddeeb8f3f6626c89237be..cc773e8a8268d99356a34616b661d529ddaed30b 100644 (file)
@@ -20,7 +20,6 @@
 
 (define-module (nyacc parse)
   #:export (make-lalr-parser make-lalr-ia-parser)
-  #:use-module (ice-9 optargs)
   #:use-module (nyacc util)
   #:use-module ((srfi srfi-43) #:select (vector-map vector-for-each))
   )
index 6b05a5b1eb1cf63ae7751e1277608591f0c8a92d..04b000f06f303b572c8562db31096df94bb727b7 100644 (file)
@@ -28,7 +28,6 @@
            ugly-print
            tzort
            )
-  #:use-module (ice-9 optargs)
   #:use-module ((srfi srfi-43) #:select (vector-fold))
   )