anchor.diff:  
   (defun update-session-id (conn headers)
     (with-slots (session-id-lock session-id) conn
  -    (bt:with-lock-held (session-id-lock)
  -      (setf session-id (cdr (assoc :x-transmission-session-id
  -                                   headers))))))
  +    (setf session-id (cdr (assoc :x-transmission-session-id
  +                                 headers)))))
   
   (define-condition-export transmission-error (error)
     ((response :initarg :response :reader transmission-error-response))
  
positive.code:                             (car body)
                              nil))
           (body (if documentation (cdr body) body))
           (declarations (if (eql (caar body) 'declare)
                             (list (car body))
                             nil))
           (body (if declarations (cdr body) body))
           (method-list (cons
                         '(conn transmission-connection)
                         (if ignore-keys-p
  
                             (loop :for item :in lambda-list
                                   :for key-seen = (eql item '&key)
                                     :then (or key-seen (eql item '&key))
                                   :when (eql item '&key)
                                     :append (list '&rest 'all-keys '&key) :into res
                                   :when (or (not key-seen)
                                             (listp item))
                                     :collect item :into res
                                   :finally (return
                                              (if key-seen
                                                  (append res (list '&allow-other-keys))
                                                  (append res (list '&rest 'all-keys)))))
                             lambda-list)))
           (tag-loop (gensym "LOOP"))
           (lambda-list (loop :for item :in lambda-list
                              :collect (if (listp item)
                                           (car item)
  
negative.code:             arguments
              (error 'transmission-error :response error-string))))))
  
  (defun transmission-request (conn method arguments)
    (loop :thereis (with-simple-restart (retry-request "Retry the request to ~
  transmission server with the same arguments")
                     (%transmission-request conn method arguments))))
  
  (def-torrent-action-request start
    "Start the given torrents by adding them to the appropriate queue.")
  (def-torrent-action-request start-now
  