anchor.diff:  
   (defparameter *null* :null
     "What to decode tnetstring null-object into")
  +
  +(declaim (inline dumb-byte-char
  +		 dumb-char-byte))
  +(defun dumb-byte-char (v)
  +  (declare (type (simple-array (unsigned-byte 8) (*)) v))
  +  "This is a dumb way to convert a byte-vector to a string.
  +However, it is 100% reversible, so you can re-encode correctly if needed.
  +Also it is significantly faster than (map 'string #code-char v) on sbcl"
  +(let ((s (make-string (length v))))
  +  (dotimes (i (length v) s)
  +    (setf (aref s i) (code-char (aref v i))))))
  +
  +#-sbcl(defun dumb-char-byte (s)
  +        (declare (type simple-string s))
  +        (let ((v (make-array (list (length s)) :element-type '(unsigned-byte 8)
  +                             :initial-element 0)))
  +          (dotimes (i (length s) v)
  +            (setf (aref v i) (char-code (aref s i))))))
  +#+sbcl(defun dumb-char-byte (s)
  +        (babel:string-to-octets s))
  +
   
   (defun read-integer (sequence start end)
     "Interprets the given subsequence as a base-10 integer in a 7-bit ASCII
  
positive.code:     ((vectorp data)
       (make-tnetstring #.(char-code #\,) (list data)))
      ((symbolp data)
       (make-tnetstring #.(char-code #\,) (list (babel:string-to-octets (symbol-name data)))))
      ((and (listp data)
            (consp (car data)))
       (make-tnetstring
        #.(char-code #\})
        (loop
  
negative.code:                                   for key = (next-tnetstring)
                                    until (eq key 'eof)
                                    for val = (next-tnetstring)
                                    collect (cons (make-keyword (dumb-byte-char key)) val)))))
                          (if (eq *dict-decode-type* :hash-table)
                              (alist-hash-table alist)
                              alist)))
  