anchor.diff:               (error 'simple-file-error
                       :pathname pathname
                       :format-control "Could not supersede ~S."
  -                    :format-arguments (list pathname)))
  -           (unless created-file
  -             (error "Cannot create ~A. ~S" pathname)))
  +                    :format-arguments (list pathname))))
             ((:overwrite) t)
             ((:append) (setf file-position file-length))
             ((nil) (return-from open-using-host nil))))
  -      (let ((stream (cond ((or (eql element-type :default)
  -                               (subtypep element-type 'character))
  -                           (assert (member external-format '(:default :utf-8))
  -                                   (external-format))
  -                           (make-instance 'fat32-file-character-stream
  -                                          :pathname pathname
  -                                          :host host
  -                                          :direction direction
  -                                          :buffer buffer
  -                                          :buffer-position buffer-position
  -                                          :position file-position
  -                                          :length file-length))
  -                          ((and (subtypep element-type '(unsigned-byte 8))
  -                                (subtypep '(unsigned-byte 8) element-type))
  -                           (assert (eql external-format :default) (external-format))
  -                           (make-instance 'fat32-file-stream
  -                                          :pathname pathname
  -                                          :host host
  -                                          :direction direction
  -                                          :buffer buffer
  -                                          :buffer-position buffer-position
  -                                          :position file-position
  -                                          :length file-length))
  -                          (t (error "Unsupported element-type ~S." element-type)))))
  -        stream))))
  +      (cond ((or (eql element-type :default)
  +                 (subtypep element-type 'character))
  +             (assert (member external-format '(:default :utf-8))
  +                     (external-format))
  +             (make-instance 'fat32-file-character-stream
  +                            :pathname pathname
  +                            :host host
  +                            :direction direction
  +                            :buffer buffer
  +                            :buffer-position buffer-position
  +                            :position file-position
  +                            :length file-length))
  +            ((and (subtypep element-type '(unsigned-byte 8))
  +                  (subtypep '(unsigned-byte 8) element-type))
  +             (assert (eql external-format :default) (external-format))
  +             (make-instance 'fat32-file-stream
  +                            :pathname pathname
  +                            :host host
  +                            :direction direction
  +                            :buffer buffer
  +                            :buffer-position buffer-position
  +                            :position file-position
  +                            :length file-length))
  +            (t (error "Unsupported element-type ~S." element-type))))))
   
   (defmethod probe-using-host ((host fat32-host) pathname)
     (multiple-value-bind (file-data file-cluster file-length) (open-file host pathname)
  
positive.code:         (assert source-start (source-start) "Source file not found. ~s" source)
          (multiple-value-bind (dest-dir dest-cluster dest-start) (open-file-metadata host dest)
            (assert (not dest-start) (dest-start) "Destination file alredy exist. ~s" dest)
            (let ((fat32 (fat-structure host))
                  (disk (partition host))
                  (fat (fat host)))
              (do-file (i source-start) source-dir
                (let ((start (if (< i 0)
                                 source-start
                                 (+ 32 i))))
                  (if (string= (file-name source)
                               (file-name dest))
                      (let ((metadata (subseq source-dir start (+ 32 source-start))))
                        (replace dest-dir metadata :start1 (next-n-spaces dest-dir (/ (length metadata) 32))))
                      ;; Write short name part
                      (let* ((pathname-name (pathname-name dest))
                             (pathname-type (pathname-type dest))
                             (name (concatenate 'string pathname-name "." pathname-type))
                             (short-name (make-short-name pathname-name pathname-type dest-dir))
                             (name-length (length name))
                             (start-offset (next-n-spaces dest-dir (if (> name-length 11)
                                                                       (1+ (ceiling
                                                                            (/ name-length 13)))
                                                                       1)))
                             (end-offset (+ start-offset (ash (if (> name-length 11)
                                                                  (ceiling (/ name-length 13))
                                                                  0)
                                                              5))))
                        ;; Copy short part
                        (let ((metadata (subseq source-dir source-start (+ 32 source-start))))
                          (replace dest-dir metadata :start1 end-offset))
                        ;; Change short name
                        (setf (read-short-name dest-dir end-offset) short-name)
                        ;; Write long name parts only if needed
                        (unless (and (>= 8 (length pathname-name))
                                     (>= 3 (length pathname-type)))
                          (setf (read-long-name dest-dir start-offset) name))))
                  (if (equalp (pathname-directory source)
                              (pathname-directory dest))
                      (loop :for part-offset :from start :to source-start :by 32
                            :do (setf (aref dest-dir part-offset) #xE5))
                      (progn (loop :for part-offset :from start :to source-start :by 32
                                   :do (setf (aref source-dir part-offset) #xE5))
                             (write-file fat32 disk source-cluster fat source-dir)))
                  (write-file fat32 disk dest-cluster fat dest-dir))))))))
  
  (defmethod file-write-date-using-host ((host fat32-host) path)
    (multiple-value-bind (parent-dir parent-cluster file-offset) (open-file-metadata host path)
  
negative.code: 
  (defmethod directory-using-host ((host fat32-host) pathname &key)
    (let ((file-data (open-file-metadata host pathname))
          (stack '()))
      (do-files (file) file-data
        t
        (push (parse-simple-file-path host
                                      (format nil
                                              (if (file-p file-data file)
                                                  "~a~a"
                                                  "~a~a>")
                                              (directory-namestring pathname)
                                              (read-file-name file-data file)))
              stack))
      stack))
  
  (defmethod ensure-directories-exist-using-host ((host fat32-host) pathname &key verbose)
    ;; TODO verbose
  