anchor.diff:    (declare (type buffer buffer)
   	   (type (or cons nil) tree))
     (cons :obj
  -	(loop until (progn (skip-spaces buffer)
  -			   (eql (fetch-char buffer) #\})) ; we may fetch-char here, as the character is a #\, to be skipped if it is not a #\}
  +	(loop until (progn (skip-until* buffer "\"}")
  +			   (eql (read-char buffer) #\}))
   	   append (multiple-value-bind (found-p key)
   		      (read-partial-key buffer tree)
   		    (progn (skip-to buffer #\:)		
  
positive.code: (define-compiler-macro parse (&whole whole string &rest keywords-to-read) ; this allows the character tree to be precompiled
    (if keywords-to-read
        `(let ((buffer (build-buffer ,string)))
  	 (skip-spaces buffer)
  	 (read-partial-object buffer (build-character-tree ,@keywords-to-read)))
        whole))
  
  
negative.code:   (labels ((delimiters-for (exponent-p float-p)
  	     (concatenate 'string (if float-p float-delimiters "") (if exponent-p exp-delimiters "") number-delimiters)))
      (let ((delimiters (delimiters-for exponent-p float-p)))
        `(progn
  	 (case (current-char ,buffer)
  	   (#\- (next-char ,buffer)
  		,(if (eq currently-reading :exponent)
  		     `(setf negate-exp -1)
  		     `(setf negate-number -1)))
  	   (#\+ (next-char ,buffer)))
  	 (let ((number (parse-integer (subseq-until ,buffer ,delimiters))))
  	   (declare (type integer number))
  	   (cond ,@(concatenate 
  		    'list
  		    (when float-p
  		      `(((char-in-arr (current-char ,buffer) ,float-delimiters)
  			 (set-read-number-part ,currently-reading ,buffer
  			   (next-char ,buffer) ; we can skip the matching character in float-delimiters after the variables have been set
  			   (read-number* ,buffer :currently-reading :float :exponent-p ,exponent-p :float-p nil :float-delimiters ,float-delimiters :exp-delimiters ,exp-delimiters :number-delimiters ,number-delimiters)))))
  		    (when exponent-p
  		      `(((char-in-arr (current-char ,buffer) ,exp-delimiters)
  			 (set-read-number-part ,currently-reading ,buffer
  			   (next-char ,buffer) ; we can skip the matching character in exp-delimiters after the variables have been set
  			   (read-number* ,buffer :currently-reading :exponent :exponent-p nil :float-p ,float-p :float-delimiters ,float-delimiters :exp-delimiters ,exp-delimiters :number-delimiters ,number-delimiters)))))
  		    `((T
  		       (set-read-number-part ,currently-reading ,buffer
  			 ,(create-parse-number-code :exponent-p (not exponent-p) :float-p (not float-p))))))))))))
  
  (defun read-number (buffer)
    (declare (type buffer buffer))
    (let ((negate-exp 1)
  	(negate-number 1))
      (read-number* buffer)))
  
  (defun skip-number (buffer)
    (declare (type buffer buffer))
  