anchor.diff:     "))")
     (:destructure (start stuff end)
   		(declare (ignore start end))
  -    (let* ((expanded
  +    (let* ((stuff
  +	    (text (mapcar #'second stuff)))
  +	   (expanded
   	    (esrap:text
   	     (do-some-expansions
   		 stuff
  
positive.code:       (:var (or
  	     (let*
  		 ((param (plush::get-parameter left))
  		  (parsed (when param (funcall (literal-number) param))))
  	       (when parsed
  		 (destructuring-bind ((val . rest)) parsed
  		   (when (emptyp rest) (second val)))))
  
negative.code:     ((:= :*= :/= :%= :+= :-=
  	 :<<= :>>= :&= :^= :\|=) 11)))
  
  (defun treeify-expr (list)
    (if
     (null (cdr list))
     (car list)
     (loop for priority from 11 downto 1
        for op = (position priority list :key (lambda (x) (and (keywordp x) (operator-priority x))))
        when op
        return (list (nth op list)
  		   (treeify-expr (subseq list 0 op))
  		   (treeify-expr (subseq list (1+ op)))))))
  
  (defrule arithmetic-expr
      (and
       unary-and-primary-expr
       (*
        (and
         arithmetic-binop
         unary-and-primary-expr)))
    (:destructure
     (start pairs)
     (let
         ((list
  	 (cons start (reduce #'append pairs))))
       (treeify-expr list))))
    
  (defun hex-digit-p (x)
    (digit-char-p x 16))
  
  (defun oct-digit-p (x)
    (digit-char-p x 8))
  
  (defrule literal-number
      (or
       (and
        "0x"
        (+ (hex-digit-p character)))
       (and
        "0"
        (+ (oct-digit-p character)))
       (and
        (+ (digit-char-p character))))
    (:lambda (x)
      (list :number
  	  (cond
  	    ((= (length x) 1)
  	     (parse-integer (text (car x))))
  	    ((string= (car x) "0x")
  	     (parse-integer (text (cadr x)) :radix 16))
  	    ((string= (car x) "0")
  	     (parse-integer (text (cadr x)) :radix 8))))))
  
  (defrule primary-expr
      (or
       (and
        #\(
        arithmetic-expr
        #\))
       literal-number
       posix-name)
    (:lambda (x)
      (cond
        ((stringp x)
         (list :var x))
        ((eql (car x) #\()
         (second x))
        ((eql (car x) :number)
         x))))
  
  (defun run-arithmetic (pt)
    (let ((op (car pt))
  