(defun stat-file-type (path-stat)
  (let ((mode (sb-posix:stat-mode path-stat)))
    (cond
      ((sb-posix:s-isdir mode))
      ((sb-posix:s-isreg mode) :regular-file)
      ((sb-posix:s-isblk mode) :block-device)
      ((sb-posix:s-ischr mode) :character-device)
      ((sb-posix:s-issock mode) :socket)
      ((sb-posix:s-islnk mode) :symlink)
      ((sb-posix:s-isfifo mode) :fifo)
      (t :other))))

                                                                            (constantly :path) (lambda (it)
                                                                                                 (format nil "~a/~a" path (sb-posix:dirent-name it)))

                                     (let ((mode (sb-posix:stat-mode stat)))
                                       (cond
                                         ((sb-posix:s-isreg mode) :regular-file)
                                         ((sb-posix:s-isblk mode) :block-device)
                                         ((sb-posix:s-ischr mode) :character-device)
                                         ((sb-posix:s-issock mode) :socket)
                                         ((sb-posix:s-islnk mode) :symlink)
                                         ((sb-posix:s-isfifo mode) :fifo)
                                         (t :other)))))))
    (error (c) (format *error-output* "~a" c))))

                                     (stat-file-type stat)))))
    (error (c) (format *error-output* "~a (~a) ~a" path (type-of c) c))))

         (net.didierverna.clon:*context* context)
         (hashes '(:md5 :sha256)))

         (net.didierverna.clon:*context* context))

           (main-ld (net.didierverna.clon:remainder :context context))
           (terpri)))))

           (let ((input (net.didierverna.clon:remainder :context context)))
             (if input
                 (main-ld input)
                 (loop for input = (read-line *standard-input*
                                              nil)
                       while input
                       for parsed = (coerce (gethash "path" (yason:parse input))
                                            'simple-string)
                       do (main-ld (list parsed)))))
           (fresh-line)))))