anchor.diff:          (if (null file-name)
               (return inode)
               (block do-files
  -              (do-files (block offset) disk superblock bgdt inode nil
  +              (do-files (block offset) disk superblock inode nil
                   (let ((directory-entry (read-linked-directory-entry block offset)))
                     (when (string= file-name (linked-directory-entry-name directory-entry))
                       (return-from find-file
  
positive.code:                  (never (zerop block-n))
                   (follow-pointer disk superblock block-n fn indirection))))))
  
  (defun read-block-n (disk superblock bgdt inode block-n)
    (let ((n -1))
      (do-file #'(lambda (block)
                   (when (= (incf n) block-n)
                     (return-from read-block-n block)))
        disk superblock bgdt inode)))
  
  (defmacro do-files ((arg var) disk superblock bgdt inode finally &body body)
    `(unless (do-file (lambda (,arg)
                        (do ((,var 0 (+ ,var (sys.int::ub16ref/le ,arg (+ 4 ,var)))))
                            ((= ,var (block-size-in-bytes disk superblock)) nil)
                          ,@body))
               ,disk ,superblock ,bgdt ,inode)
       ,finally))
  
  ;;; Host integration
  
negative.code:                                                                     :collect (sys.int::ub32ref/le superblock i)))
                           :checksum (sys.int::ub32ref/le superblock 1020))))))
  
  (defun bytes-per-block (superblock)
    (ash 1024 (superblock-log-block-size superblock)))
  
  (defun sectors-per-block (disk superblock)
    (/ (bytes-per-block superblock)
       (block-device-sector-size disk)))
  
  (defun read-block (disk superblock block-n &optional (n-blocks 1))
    (let* ((n-sectors (sectors-per-block disk superblock))
           (sector-n (* n-sectors
                        (if (= (superblock-log-block-size superblock) 1)
                            (1+ block-n) block-n))))
      (block-device-read-sector disk sector-n (* n-blocks n-sectors))))
  
  (defun block-group (inode-n superblock)
    "Return block group that an inode lives in"
    (floor (/ (1- inode-n) (superblock-inodes-per-group superblock))))
  
  (defun index (inode-n superblock)
    "Return index of an inode"
    (mod (1- inode-n) (superblock-inodes-per-group superblock)))
  
  (defun offset (inode-n superblock)
    "Return byte address within the inode table"
  