anchor.diff:                       "Transmission server signaled an error: \"~A\"."
                        (transmission-error-response condition)))))
   
  -(defun transmission-request (conn method arguments)
  +(defun %transmission-request (conn method arguments)
     (check-type conn transmission-connection)
     (check-type method string)
     (check-type arguments (or hash-table list))
     (flet ((get-res (url content)
  -           (drakma:http-request
  -            url
  -
  -            :method :post
  -            :basic-authorization (slot-value conn 'credentials)
  -            :additional-headers `(("X-Transmission-Session-Id" . ,(slot-value conn 'session-id)))
  -            :content content)))
  +           (drakma:http-request url
  +                                :method :post
  +                                :basic-authorization (slot-value conn 'credentials)
  +                                :additional-headers `(("X-Transmission-Session-Id" . ,(slot-value conn 'session-id)))
  +                                :content content)))
       (let* ((content-hash #h(equalp
                               "method" method
                               "arguments" arguments))
  
positive.code: 
  (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))))))
  
  (define-condition-export transmission-error (error)
    ((response :initarg :response :reader transmission-error-response))
  
negative.code:                             (car body)
                              nil))
           (body (if documentation (cdr body) body))
           (declarations (if (eql (caar body) 'declare) (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 (append res
                                                                 (if key-seen
                                                                     '(&allow-other-keys)
                                                                     '(&rest all-keys)))))
                                  lambda-list)))
           (lambda-list (loop :for item :in lambda-list
                              :collect (if (listp item)
                                           (car item)
  