anchor.diff:  (defun read-key (buffer)
     "reads a key from the key-value list"
     (declare (type buffer buffer))
  -  (skip-to buffer #\")
     (parse-string buffer))
   
   (defun skip-key (buffer)
  
positive.code:   "Skips a value from the stream.
   This searches for the first meaningful character, and delegates to the right function for skipping that"
    (declare (type buffer buffer))
    (skip-spaces buffer)
    (case (fetch-char buffer)
      (#\" (skip-string buffer))
      (#\{ (skip-object buffer))
      (#\[ (skip-array buffer))
      (#\t (incf (buffer-index buffer) 3))
      (#\f (incf (buffer-index buffer) 4))
      (#\n (incf (buffer-index buffer) 3))
      (T (skip-number buffer)))
    (values))
  
  (defun skip-string (buffer)
    (declare (type buffer buffer))
    "Skips the contents of an input string from the buffer.  Assumes the first #\" has been read"
    (skip-to/ buffer #\"))
  
  (defun parse-string (buffer)
    "Reads a JSON string from the stream (assumes the first \" is missing and NO escaped characters are in there"
    (declare (type buffer buffer))
    (let ((result (subseq-until/ buffer #\")))
      (next-char buffer)
      result))
  
  (defun skip-array (buffer)
    (declare (type buffer buffer))
    "Skips the contents of an array from the buffer.  Assumes the first #\[ is already read from the buffer"
    (decr-char buffer)
    (loop 
       until (progn (skip-spaces buffer)
  		  (next-char buffer)
  		  (eql (peek-behind-char buffer) #\]))
       do (skip-value buffer))
    )
  
  (defun read-array (buffer)
    "Reads a JSON array from the stream (assumes the first [ is missing"
    (declare (type buffer buffer))
    (decr-char buffer)
    (loop 
       until (progn (skip-spaces buffer)
  		  (next-char buffer)
  		  (eql (peek-behind-char buffer) #\]))
       collect (read-value buffer)))
  
  (defun read-number (buffer)
    (declare (type buffer buffer))
    (decr-char buffer)
    (let ((whole-part (parse-integer (subseq-until buffer #\] #\} #\, #\.)))) ;; only these chars can delimit the whole part of a number 
      (if (eql (current-char buffer) #\.)
  	(progn 
  
negative.code:   (loop do (next-char/ buffer)
       until (eql (current-char buffer) last-char)))
  
  (defun skip-until* (buffer char-arr)
    "Skips characters until one of the characters in <char-arr> has been found.  The character which was found is not read from the buffer."
    (declare (type simple-string char-arr)
     	   (type buffer buffer))
    (when +do-skip-spaces+
      (flet ((char-in-arr ()
  	     (loop for c across char-arr
  		when (eql (current-char buffer) (the character c))
  		do (return-from char-in-arr T))
  	     nil))
        (loop until (char-in-arr)
  	 do (next-char buffer)))))
  
  (defun skip-spaces (buffer)
    "Skips spaces, tabs and newlines until a non-space character has been found"
  