anchor.diff:       do (next-char buffer))
     (subseq-buffer-mark buffer))
   
  +(defun subseq-tree (buffer end-char tree)
  +  "Returns a sequence of the buffer, reading everything that matches with the given tree before end-char is found.  end-char is not read from the buffer
  + Returns nil if no sequence matching the tree could be found.  It then stops iterating at the failed position"
  +  (declare (type buffer buffer)
  +	   (type character end-char))
  +  (mark-buffer buffer)
  +  (let ((accepted-p nil))
  +    (loop while (and tree (char/= (current-char buffer) end-char))
  +       do (progn (multiple-value-setq (tree accepted-p) (iterate-tree tree (current-char buffer)))
  +		 (next-char buffer)))
  +    (values accepted-p (if accepted-p (subseq-buffer-mark buffer) ""))))
  +
   (defun read-object (buffer)
     "reads a key-value pair into the hash"
     (declare (type buffer buffer))
  -  (let ((obj nil))
  -    (loop until (progn (skip-spaces buffer)
  -		       (char= (fetch-char buffer) #\})) ; we may read-char here, as the character is a , to be skipped if it is not a }
  -       collect (cons (read-key buffer) (read-value buffer))) 
  -    obj))
  +  (loop until (progn (skip-spaces buffer)
  +		     (char= (fetch-char buffer) #\})) ; we may fetch-char here, as the character is a #\, to be skipped if it is not a #\}
  +     collect (cons (read-key buffer) (read-value buffer))))
  +
  +(defun read-partial-object (buffer tree)
  +  "Reads an object from the buffer, but only when the key matches a key in the tree"
  +  (declare (type buffer buffer)
  +	   (type (or cons nil) tree))
  +  (loop until (progn (skip-spaces buffer)
  +		     (char= (fetch-char buffer) #\})) ; we may fetch-char here, as the character is a #\, to be skipped if it is not a #\}
  +     append (multiple-value-bind (found-p key)
  +		(read-partial-key buffer tree)
  +	      (if found-p
  +		  (list (cons key (read-value buffer)))
  +		  (progn (skip-value buffer) nil)))))
  +
  +(defun skip-object (buffer)
  +  "Skips an object from the buffer"
  +  (declare (type buffer buffer))
  +  (loop until (progn (skip-spaces buffer)
  +		     (char= (fetch-char buffer) #\})) ; we may read-char here, as the character is a , to be skipped if it is not a }
  +     do (skip-key buffer) (skip-value buffer)))
  +
  +(defun read-partial-key (buffer tree)
  +  "reads a key from the buffer.  Returns (values key T) if the key was found as a valid key in the tree, or (values nil nil) if it was not"
  +  (declare (type buffer buffer)
  +	   (type (or cons nil) tree))
  +  (skip-to buffer #\")
  +  (multiple-value-bind (accepted-p solution)
  +      (subseq-tree buffer #\" tree)
  +    (declare (type (or nil T) accepted-p)
  +	     (type simple-string solution))
  +    (skip-to buffer #\") ;; clean up mess
  +    (values accepted-p solution)))
   
   (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)
  +  "reads a key from the key-value list"
  +  (declare (type buffer buffer))
  +  (skip-to buffer #\")
  +  (skip-string buffer))
   
   (defun read-value (buffer)
     "Reads a value from the stream.
  
positive.code: 	  ((string= meaning #\[)
  	   (read-array buffer))
  	  ((char= meaning #\t)
  	   T)
  	  ((char= meaning #\f)
  	   nil)
  	  ((char= meaning #\n)
  	   nil)
  	  (T
  	   (read-number 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))
    (subseq-until buffer #\"))
  
  (defun read-array (buffer)
    "Reads a JSON array from the stream (assumes the first [ is missing"
  
negative.code: 			(build-tree matching-lists))))))
  
  (defun iterate-tree (tree char)
    "Iterates a character-tree with the given character
   Returns two values, being the new tree and whether or not this is an end-point."
    (declare (type (or cons nil) tree)
  	   (type character char))
    (let ((solution (rest (find char tree :key #'first :test #'char=))))
  