anchor.diff:  
     (precedence-rules <expr>
   
  -    ;; scope
  -    ((rule <scope-ref> ::= <expr> (* '("::" nil nil) <expr>)))
  -
  -    ;; grouping
  -    ((rule <group> ::= <expr>))
  -
  -    ;; postfix and accessors
  -    ((rule <post++> ::= <expr> '("++" nil t))
  -     (rule <post--> ::= <expr> '("--" nil t))
  -     (rule <array-ref> ::= <expr> (* '("[" nil nil) <expr> '("]" nil t)))
  -     (rule <field-ref> ::= <expr> '("." nil nil) <class-or-field> (* '("." nil nil) <class-or-field>))
  -     (rule <field-ref-ptr> ::= <expr> '("->" nil nil) <class-or-field> (* '("->" nil nil) <class-or-field>))
  -     (rule <field-ref-this> ::= '("this->" t nil) <class-or-field>)
  -     (rule <field-ref-static> ::= (* <class-ref> '("::" nil nil)) <class-or-field>))
  -
  -    ;; unary
  -    ((rule <++> (assoc :right) ::= '("++" t nil) <expr>)
  -     (rule <--> (assoc :right) ::= '("--" t nil) <expr>)
  -     (rule <positive> (assoc :right) ::= '("+" t nil) <expr>)
  -     (rule <negative> (assoc :right) ::= '("-" t nil) <expr>)
  -     (rule <~> (assoc :right) ::= '("~" t nil) <expr>)
  -     (rule <!> (assoc :right) ::= '("!" t nil) <expr>)
  -     (rule <addr> (assoc :right) ::= '("&" t nil) <expr>)
  -     (rule <deref> (assoc :right) ::= '("*" t nil) <expr>)
  -     (rule <new> (assoc :right) ::= "new" <type-expr> <arg-list>)
  -     (rule <sizeof> (assoc :right) ::= "sizeof" <expr>)
  -     (rule <cast> (assoc :right) ::= 'open-paren <type-expr> 'close-paren <expr>))
  -
  -    ;; member pointer selectors
  -    ((rule <member-ref> ::= <expr> '(".*" nil nil) <class-or-field>)
  -     (rule <member-ref-ptr> ::= <expr> '("->*" nil nil) <class-or-field>))
  -
  -    ;; multiplicative
  -    ((rule <*> ::= <expr> "*" <expr> (* "*" <expr>))
  -     (rule </> ::= <expr> "/" <expr>)
  -     (rule <%> ::= <expr> "%" <expr>))
  -
  -    ;; additive
  -    ((rule <+> ::= <expr> "+" <expr> (* "+" <expr>))
  -     (rule <-> ::= <expr> "-" <expr> (* "-" <expr>)))
  -
  -    ;; shift
  -    ((rule <<<> ::= <expr> "<<" <expr>)
  -     (rule <>>> ::= <expr> ">>" <expr>))
  -
  -    ;; relational
  -    ((rule <<> ::= <expr> "<" <expr>)
  -     (rule <>> ::= <expr> ">" <expr>)
  -     (rule <<=> ::= <expr> "<=" <expr>)
  -     (rule <>=> ::= <expr> ">=" <expr>))
  -
  -    ;; equality
  -    ((rule <==> ::= <expr> "==" <expr>)
  -     (rule <!=> ::= <expr> "!=" <expr>))
  -
  -    ;; bitwise AND
  -    ((rule <bit-and> ::= <expr> "&" <expr>))
  -
  -    ;; bitwise XOR
  -    ((rule <bit-xor> ::= <expr> "^" <expr>))
  -
  -    ;; bitwise OR
  -    ((rule <bit-or> ::= <expr> "|" <expr>))
  -
  -    ;; logical AND
  -    ((rule <and> ::= <expr> "&&" <expr>))
  -
  -    ;; logical OR
  -    ((rule <or> ::= <expr> "||" <expr>))
  -
  -    ;; conditional
  -    ((rule <?> (assoc :right) ::= <expr> "?" 'push-wrap-marker <expr> ":" <expr> 'pop-wrap-marker))
  -
  -    ;; assignment
  -    ((rule <set> (assoc :right) ::= <expr> "=" <expr>)
  -     (rule <=> (assoc :right) ::= <expr> "=" <expr>)
  -     (rule <+=> (assoc :right) ::= <expr> "+=" <expr>)
  -     (rule <-=> (assoc :right) ::= <expr> "-=" <expr>)
  -     (rule <*=> (assoc :right) ::= <expr> "*=" <expr>)
  -     (rule </=> (assoc :right) ::= <expr> "/=" <expr>)
  -     (rule <%=> (assoc :right) ::= <expr> "%=" <expr>)
  -     (rule <bit-and=> (assoc :right) ::= <expr> "&=" <expr>)
  -     (rule <bit-xor=> (assoc :right) ::= <expr> "^=" <expr>)
  -     (rule <bit-or=> (assoc :right) ::= <expr> "|=" <expr>)
  -     (rule <<<=> (assoc :right) ::= <expr> "<<=" <expr>)
  -     (rule <>>=> (assoc :right) ::= <expr> ">>=" <expr>))
  -
  -    ;; comma
  -    ((rule <progn> ::= <expr> (* 'comma <expr>))))
  +                    ;; scope
  +                    ((rule <scope-ref> ::= <expr> (* '("::" nil nil) <expr>)))
  +
  +                    ;; grouping
  +                    ((rule <group> ::= <expr>))
  +
  +                    ;; postfix and accessors
  +                    ((rule <post++> ::= <expr> '("++" nil t))
  +                     (rule <post--> ::= <expr> '("--" nil t))
  +                     (rule <array-ref> ::= <expr> (* '("[" nil nil) <expr> '("]" nil t)))
  +                     (rule <field-ref> ::= <expr> '("." nil nil) <class-or-field> (* '("." nil nil) <class-or-field>))
  +                     (rule <field-ref-ptr> ::= <expr> '("->" nil nil) <class-or-field> (* '("->" nil nil) <class-or-field>))
  +                     (rule <field-ref-this> ::= '("this->" t nil) <class-or-field>)
  +                     (rule <field-ref-static> ::= (* <class-ref> '("::" nil nil)) <class-or-field>))
  +
  +                    ;; unary
  +                    ((rule <++> (assoc :right) ::= '("++" t nil) <expr>)
  +                     (rule <--> (assoc :right) ::= '("--" t nil) <expr>)
  +                     (rule <positive> (assoc :right) ::= '("+" t nil) <expr>)
  +                     (rule <negative> (assoc :right) ::= '("-" t nil) <expr>)
  +                     (rule <~> (assoc :right) ::= '("~" t nil) <expr>)
  +                     (rule <!> (assoc :right) ::= '("!" t nil) <expr>)
  +                     (rule <addr> (assoc :right) ::= '("&" t nil) <expr>)
  +                     (rule <deref> (assoc :right) ::= '("*" t nil) <expr>)
  +                     (rule <new> (assoc :right) ::= "new" <type-expr> <arg-list>)
  +                     (rule <sizeof> (assoc :right) ::= "sizeof" <expr>)
  +                     (rule <cast> (assoc :right) ::= 'open-paren <type-expr> 'close-paren <expr>))
  +
  +                    ;; member pointer selectors
  +                    ((rule <member-ref> ::= <expr> '(".*" nil nil) <class-or-field>)
  +                     (rule <member-ref-ptr> ::= <expr> '("->*" nil nil) <class-or-field>))
  +
  +                    ;; multiplicative
  +                    ((rule <*> ::= <expr> "*" <expr> (* "*" <expr>))
  +                     (rule </> ::= <expr> "/" <expr>)
  +                     (rule <%> ::= <expr> "%" <expr>))
  +
  +                    ;; additive
  +                    ((rule <+> ::= <expr> "+" <expr> (* "+" <expr>))
  +                     (rule <-> ::= <expr> "-" <expr> (* "-" <expr>)))
  +
  +                    ;; shift
  +                    ((rule <<<> ::= <expr> "<<" <expr>)
  +                     (rule <>>> ::= <expr> ">>" <expr>))
  +
  +                    ;; relational
  +                    ((rule <<> ::= <expr> "<" <expr>)
  +                     (rule <>> ::= <expr> ">" <expr>)
  +                     (rule <<=> ::= <expr> "<=" <expr>)
  +                     (rule <>=> ::= <expr> ">=" <expr>))
  +
  +                    ;; equality
  +                    ((rule <==> ::= <expr> "==" <expr>)
  +                     (rule <!=> ::= <expr> "!=" <expr>))
  +
  +                    ;; bitwise AND
  +                    ((rule <bit-and> ::= <expr> "&" <expr>))
  +
  +                    ;; bitwise XOR
  +                    ((rule <bit-xor> ::= <expr> "^" <expr>))
  +
  +                    ;; bitwise OR
  +                    ((rule <bit-or> ::= <expr> "|" <expr>))
  +
  +                    ;; logical AND
  +                    ((rule <and> ::= <expr> "&&" <expr>))
  +
  +                    ;; logical OR
  +                    ((rule <or> ::= <expr> "||" <expr>))
  +
  +                    ;; conditional
  +                    ((rule <?> (assoc :right) ::= <expr> "?" 'push-wrap-marker <expr> ":" <expr> 'pop-wrap-marker))
  +
  +                    ;; assignment
  +                    ((rule <set> (assoc :right) ::= <expr> "=" <expr>)
  +                     (rule <=> (assoc :right) ::= <expr> "=" <expr>)
  +                     (rule <+=> (assoc :right) ::= <expr> "+=" <expr>)
  +                     (rule <-=> (assoc :right) ::= <expr> "-=" <expr>)
  +                     (rule <*=> (assoc :right) ::= <expr> "*=" <expr>)
  +                     (rule </=> (assoc :right) ::= <expr> "/=" <expr>)
  +                     (rule <%=> (assoc :right) ::= <expr> "%=" <expr>)
  +                     (rule <bit-and=> (assoc :right) ::= <expr> "&=" <expr>)
  +                     (rule <bit-xor=> (assoc :right) ::= <expr> "^=" <expr>)
  +                     (rule <bit-or=> (assoc :right) ::= <expr> "|=" <expr>)
  +                     (rule <<<=> (assoc :right) ::= <expr> "<<=" <expr>)
  +                     (rule <>>=> (assoc :right) ::= <expr> ">>=" <expr>))
  +
  +                    ;; comma
  +                    ((rule <progn> ::= <expr> (* 'comma <expr>))))
   
     (rule <call> ::= (* <ns-ref> '("::" nil nil)) 'pascal-case :identifier <arg-list>)
     (rule <call-method> ::= <expr> '("." nil nil) 'pascal-case :identifier <arg-list>)
  
positive.code:   (rule <stmt-no-while> (naked) ::= (one-of <_> <//> <stmt-no-var-while> <var>))
    (rule <stmt-no-var> (naked) ::= (one-of <_> <//> <stmt-no-var-while> <while>))
    (rule <stmt-no-var-while> (naked) ::=
  	(one-of (group (one-of <expr> <return> <goto> <throw> <break> <continue> <delete>) 'semicolon)
  		<block> <if> <for> <do> <switch> <try> <label>))
  
    (rule <var> ::=
  	(unordered (? <const>) (? <volatile>) (? <static>) (? <extern>) <type>)
  	'lower-case :name
  	(? (one-of <init> <constructor-call>))
  	'semicolon)
  
    (rule <for.while.progn> <var> ::= <type> :name (? <init>))
  
  
negative.code:   (rule <macro-call> ::= 'upper-case :macro-name <arg-list>)
  
    (rule <namespace> ::= "namespace" 'lower-case :name 'begin-block 'decrease-indent
          (* <definition>)
          'vertical-space
          'increase-indent 'end-block-no-new-line "// namespace" 'lower-case :name 'new-line)
  
    (rule <using> ::= "using" :namespace (* '("::" nil nil) (one-of :namespace <class-ref>)) 'semicolon 'new-line)
  
  