anchor.diff:  			 (+ +block+ (props-header-size props) (* +block+ i)))
   	  (write-sequence buff stream))))))
   
  +
  +      
  +
  +  
  
positive.code: 			      :count (+ start count))))
      (with-locked-mapping (stream)
        (let ((props (blog-props blog)))
  	(do ((i (props-index props) (next-index i (props-nblocks props)))
  	     (cnt 0)
  	     (id 0)
  	     (timestamp nil)
  	     (done nil))
  	    (done
  	     (progn 
  	       ;; update the log props so that we advance
  	       ;; but don't write it to the log because only writers do that 
  	       (setf (props-index props) i
  		     (props-id props) id)
  	       
  	       (values cnt id timestamp)))
  	  (file-position stream
  			 (+ +block+ (props-header-size props) (* +block+ i)))
  	  (let* ((e (read-blog-entry-props stream))
  		 (rc (logand (entry-count e) (lognot +flag-more+))))
  	    (read-sequence sequence stream
  			   :start (xdr-block-offset blk)
  			   :end (+ (xdr-block-offset blk) rc))
  	    (incf (xdr-block-offset blk) rc)
  	    (incf cnt rc)
  	    (when (zerop (logand (entry-count e) +flag-more+))
  	      (setf done t))
  	    ;; TODO: check the id doesn't change
  	    (setf id (entry-id e)
  		  timestamp (entry-timestamp e))))))))
  
  
  (declaim (ftype (function (blog) *) read-entry-details))
  (defun read-entry-details (blog)
  
negative.code: 	   #:close-blog
  	   #:reset-blog
  	   #:sync-blog 
  
  	   ;; reading 
  	   #:read-entry
  	   #:read-entry-details
  	   #:read-entries
  
  	   ;; writing 
  	   #:write-entry 
  	   
  	   ;; user accessible header 
  	   #:read-header
  	   #:write-header
  	   
  	   ;; read properties 
  	   #:blog-properties))
  	   
  (in-package #:pounds.blog)
  