anchor.diff:    (format stream "~a"
             (with-output-to-string (s)
               (with-mp4-atom-slots (me)
  -              (format s "ATOM: type: <~a> @ ~:d of size ~:d"
  -                      (as-string atom-type) atom-file-pos atom-size))
  +              (format s "atom:: type: <~a> @ ~:d of size ~:d"
  +                      atom-type atom-file-pos atom-size))
               (if (typep me 'atom-data)
                   (with-slots (atom-version atom-flags atom-value atom-type) me
  -                  (format s " having ilst fields:verison = ~d, flags = ~x, data = ~x"
  +                  (format s " having ilst fields: verison = ~d, flags = ~x, data = ~x"
                             atom-version atom-flags
  -                          (if (typep atom-value 'array) (printable-array atom-value) atom-value)))))))
  +                          (if (typep atom-value 'array)
  +                              (printable-array atom-value) atom-value)))))))
   
   (defun is-valid-m4-file (mp4-file)
     "Make sure this is an MP4 file.  Quick check: is first atom (at file-offset 4) == FSTYP?
  
positive.code:   (declare #.utils:*standard-optimize-settings*)
    (let* ((pos (stream-seek mp4-file))
           (siz (stream-read-u32 mp4-file))
           (typ (stream-read-u32 mp4-file))
           (atom))
      (declare (type fixnum pos siz typ))
  
      (when (= 0 siz)
        (error "trying to make an atom ~a with size of 0 at offset ~:d in file ~a"
               (as-string typ) pos (stream-filename mp4-file)))
  
      (setf atom (make-instance (find-atom-class typ) :atom-size siz
                                                      :atom-type typ
                                                      :atom-file-pos pos
                                                      :parent parent
                                                      :mp4-file mp4-file))
      atom))
  
  (defmethod vpprint ((me mp4-atom) stream)
  
negative.code: ;;; Copyright (c) 2013, Mark VandenBrink. All rights reserved.
  (in-package #:mp4-atom)
  
  ;;;; ATOMS
  ;;;
  ;;; A word about atoms (aka "boxes").  There are three kinds of atoms: ones that
  ;;; are containers, ones that are data, and ones that are both. A lot of the
  ;;; taggers out there mostly ignore third class and treat "container atoms that
  ;;; also have data" as a big blob of data that they rummage around in via
  ;;; indices.  Seems sort of broken, IMHO, so we'll try to handle all three if
  ;;; at all possible.
  ;;;
  
  (defun mk-atom-class-name (name)
    "Create an atom class name by concatenating ATOM- with NAME"
    (declare #.utils:*standard-optimize-settings*)
    (string-upcase (concatenate 'string "atom-" name)))
  (utils:memoize 'mk-atom-class-name)
  
  (eval-when (:compile-toplevel :load-toplevel :execute)
    (defun as-string (atom-type)
      "Given an integer, return the string representation"
      (declare #.utils:*standard-optimize-settings*)
      (with-output-to-string (s nil)
        (write-char (code-char (ldb (byte 8 24) atom-type)) s)
        (write-char (code-char (ldb (byte 8 16) atom-type)) s)
        (write-char (code-char (ldb (byte 8 8)  atom-type)) s)
        (write-char (code-char (ldb (byte 8 0)  atom-type)) s)))
  
    (defun as-octet (c)
      "Used below so that we can create atom 'types' from char/ints"
      (declare #.utils:*standard-optimize-settings*)
  