anchor.diff:                             (create-directory-entry new-dir ".." "" NIL 0)
                              cluster-n)
               ;; Write to disk
  -            (write-file (fat-structure host)
  -                        (partition host)
  -                        cluster-number
  -                        (fat host) new-dir)))
  +            (write-file fat32 (partition host) cluster-number fat new-dir)))
           ;; Write parent directory to disk
  -        (write-file (fat-structure host) (partition host) cluster-n (fat host) directory)
  +        (write-file fat32 (partition host) cluster-n fat directory)
           ;; Write fat
  -        (write-fat (partition host) (fat-structure host) (fat host))
  +        (write-fat (partition host) fat32 fat)
           ;; Return cluster-number
           cluster-number))))
   
  
positive.code: (defun create-file (host directory cluster-n pathname-name pathname-type previous-p attributes)
    "Create file/directory"
    (multiple-value-bind (time date) (get-fat32-time)
      (let ((offset)
            (cluster-size (bytes-per-cluster (fat-structure host)))
            (cluster-number (next-free-cluster (fat host) 3)))
        ;; Terminate cluster list (allocate one cluster to the file)
        (setf (aref (fat host) cluster-number)
              (last-cluster-value (fat-structure host)))
        (multiple-value-setq (offset directory)
          (create-directory-entry directory pathname-name pathname-type previous-p
                                  cluster-size))
  
negative.code:         :for i :from 0
          :for cluster-n := (sys.int::ub32ref/le file-allocation-table offset)
          :do (setf (aref fat i) cluster-n)
          :finally
            (setf (fat32-%fat-dirty-bits fat32) (make-array (ceiling (fat32-%sectors-per-fat fat32) 32)
                                                            :element-type '(unsigned-byte 32)
                                                            :initial-element 0))
            (return fat)))
  
  (defmethod write-fat (disk (fat32 fat32) fat)
    (let* ((dirty-bits (fat32-%fat-dirty-bits fat32))
           (sector-size (block-device-sector-size disk))
           (clusters-per-sector (/ sector-size 4))
           (fat-offset (fat-%n-reserved-sectors fat32))
           (buf (make-array sector-size :element-type '(unsigned-byte 8))))
      (dotimes (word-idx (length dirty-bits))
        (when (/= (aref dirty-bits word-idx) 0)
          (let ((bits (aref dirty-bits word-idx)))
            (dotimes (bit-idx 32)
              (when (logbitp bit-idx bits)
                (let* ((sector (+ (* word-idx 32) bit-idx))
                       (word-offset (* sector clusters-per-sector)))
                  (dotimes (i clusters-per-sector)
                    (setf (sys.int::ub32ref/le buf (* 4 i)) (aref fat (+ word-offset i))))
                  (block-device-write disk (+ sector fat-offset) 1 buf)))))
          (setf (aref dirty-bits word-idx) 0)))))
  
  (defun set-fat32 (fat32 fat idx value)
    (setf (aref fat idx) value)
    (let* ((dirty-bits (fat32-%fat-dirty-bits fat32))
           (clusters-per-sector (/ (fat-%bytes-per-sector fat32) 4))
           (sector (floor idx clusters-per-sector)))
      (multiple-value-bind (word-idx bit-idx) (floor sector 32)
        (setf (aref dirty-bits word-idx)
              (dpb 1 (byte 1 bit-idx) (aref dirty-bits word-idx))))))
  
  (defmethod root-dir-sectors ((fat12 fat12))
    (floor (/ (+ (ash (fat-%n-root-entry fat12) 5)
  