anchor.diff:  
   (defun parse (x)
     (awhen (parse-labels x)
  -    (with (f [? (& (cons? _)
  -                   (in? _. 'number 'string)) ._
  -                (cons? _)  (. (f _.) (f ._))
  -                _])
  -      (f (parse-0 !)))))
  +    (parse-atoms (parse-0 !))))
   
   (defun parse-stream (i)
     (with-temporary *parser-stream* i
  
positive.code: (defun parse-directive (x)
    `((,(car x.) ,(cdr x.) ,@.x)))
  
  (defun parse-0 (x)
    (when x
      (?
  
negative.code:                (values (case (cdr ..x.)
                         'x  'absx
                         'y  'absy
                         (parser-error "Index register expected instead of '~A'."
                                       (cdr ..x.)))
                       x.)
                 (parser-error "Index register expected."))
              (parser-error "Comma expected instead of ~A."
                            (car .x.))))
      (bracket-open? x.)
        (progn
          (| (number-or-identifier? .x.)
             (parser-error "Expression expected instead of ~A."
                           (car .x.)))
          (? (bracket-close? ..x.)
             (?
               (comma? ...x.)  (? (eq 'y (cdr ....x.))
                                  (values 'izpy .x.)
                                  (parser-error "Index register Y expected."))
               ...x.           (parser-error "Comma or end of line expected instead of ~A."
                                             (car ...x.))
               (values 'indi .x.))
             (comma? ..x.)
               (? (identifier? ...x.)
                  (? (eq 'x (cdr ...x.))
                     (? (bracket-close? ....x.)
                        (values 'izpx .x.)
                        (parser-error "Closing bracket expected instead of ~A."
                                      ....x.))
                     (parser-error "Index register X expected."))
                  (parser-error "Index register X expected."))
             (parser-error "~A closing bracket."
                           (? (member-if #'bracket-close? ...x)
                              "Misplaced"
                              "Missing"))))
      (parser-error "Syntax error at ~A." x.)))
  
  (defun parse-assignment (x)
  