anchor.diff:  	   (setf (eighth last-part) lines)
   	   (setf last-part nil))
   	 (cond (endp
  -		(format t "End tag of boundary=~A~%" boundary)
  -		(force-output t)
  +		; (format t "End tag of boundary=~A~%" boundary)
   		(multiple-value-bind (super sub params)
   		    (content-type part)
   		  (declare (ignore super))
   		  (let ((result `(,@(nreverse parts) ,sub ,params nil nil)))
  -		    (format t "Multipart-Structure: ~A~%" result)
  -		    (force-output t)
  +		    ; (format t "Multipart-Structure: ~A~%" result)
   		    (return result))))
   	       (t
   		(multiple-value-bind (headers hoctets) (read-rfc2822-header stream)
  -		  (format t "Headers read ~A" hoctets)
  -		  (force-output t)
  +		 ; (format t "Headers read ~A" hoctets)
   		  (let ((content-type (or (cdr (assoc :content-type headers))
   					  "text/plain")))
   		    (multiple-value-bind (super sub params) (parse-content-type content-type)
  
positive.code:   (unless (slot-boundp message 'bodystructure)
      (setf (bodystructure message) (compute-bodystructure message))))
  
  (defun read-line-counted (in-stream &optional (eof-error-p t) eof-value)
    (let ((octets 0)
  	(line-end-p nil))
      (flet ((peek ()
  	     (peek-char nil in-stream))
  	   (consume ()
  	     (prog1
  		 (read-char in-stream)
  	       (incf octets))))
         (with-output-to-string (line)
  	 (handler-case
  	     (tagbody
  	      start (let ((c (peek)))
  		      (case c
  			(#\return (consume) (go cr))
  			(#\linefeed (consume) (go lf))
  			(otherwise (write-char (consume) line) (go start))))
  		
  	      lf (setf line-end-p 1)
  		(go end)
  		
  	      cr (setf line-end-p 1)
  		(let ((c (peek)))
  		  (case c
  		    (#\linefeed (consume) (go crlf))
  		    (otherwise (go end))))
  		
  	      crlf (setf line-end-p 2) (go end)
  		
  	      end
  		(return-from read-line-counted
  		  (values (get-output-stream-string line)
  			  octets
  			  (not (null line-end-p)))))
        (end-of-file ()(let ((result (get-output-stream-string line)))
                         (cond ((plusp (length result))
  			      (return-from read-line-counted
  				(values result octets (not (null line-end-p)))))
  			     (line-end-p
  			      (return-from read-line-counted
  				(values result octets t)))
  			     (t
  			      (if eof-error-p
  				  (error 'end-of-file :stream in-stream)
  				  (return-from read-line-counted
  				  (values eof-value octets nil))))))))))))
  
  (defun scan-forward-boundary-tag (stream boundary)
    (let ((tag (concatenate 'string "--" boundary)))
      (let ((lines 0)
  	  (octets 0)
  	  line line-octets line-end-p)
        (loop (multiple-value-setq (line line-octets line-end-p)
  		(read-line-counted stream))
  	    (when (string-prefixp tag line)
  	      (return))
  	    
  	    (when line-end-p
  	      (incf octets line-octets)
  	      (incf lines)))
  
        (if (string-prefixp (concatenate 'string tag "--") line)
  	  (progn (format t "End tag in f-b-t~%")
  		 (force-output t)
  		 (values octets lines t))
  	  (values octets lines nil)))))
  			        
  (defun compute-bodystructure (message)
    (compute-bodystructure-using-folder (folder message) message))
  
negative.code: 
      (multiple-value-bind (super sub params)
  	(content-type part)
        (unless (getf params :charset)
          (setf params (list* :charset "us-ascii" params)))
        (let ((result (list super sub params nil nil (content-transfer-encoding part) octets lines nil nil nil)))
  	(force-output t)
  	result))))
  