anchor.diff:      (case c
         (#\" nil)                         ; End of string
         (#\\ (let ((c (read-char stream)))
  -             (let ((unescaped (cdr (assoc c +json-lisp-escaped-chars+))))
  -               (typecase unescaped
  -                 (character unescaped)
  -                 (cons
  -                  (destructuring-bind (len . rdx) unescaped
  -                    (let ((code
  -                           (let ((repr (make-string len)))
  -                             (dotimes (i len)
  -                               (setf (aref repr i) (read-char stream)))
  -                             (handler-case (parse-integer repr :radix rdx)
  -                               (parse-error ()
  -                                 (json-syntax-error stream esc-error-fmt
  -                                                    (format nil "\\~C" c)
  -                                                    repr))))))
  -                      (restart-case
  -                          (or (and (< code char-code-limit)
  -                                   (code-char code))
  -                              (error 'no-char-for-code :code code))
  -                        (substitute-char (char)
  -                          :report "Substitute another char."
  -                          :interactive
  -                          (lambda ()
  -                            (format *query-io* "Char: ")
  -                            (list (read-char *query-io*)))
  -                          char)
  -                        (pass-code ()
  -                          :report "Pass the code to char handler."
  -                          code)))))
  -                 (t (if *use-strict-json-rules*
  -                        (json-syntax-error stream esc-error-fmt "\\" c)
  -                        c))))))
  +             (escaped-char-dispatch c
  +               :code-handler
  +                 ((len rdx)
  +                  (let ((code
  +                         (let ((repr (make-string len)))
  +                           (dotimes (i len)
  +                             (setf (aref repr i) (read-char stream)))
  +                           (handler-case (parse-integer repr :radix rdx)
  +                             (parse-error ()
  +                               (json-syntax-error stream esc-error-fmt
  +                                                  (format nil "\\~C" c)
  +                                                  repr))))))
  +                    (restart-case
  +                        (or (and (< code char-code-limit) (code-char code))
  +                            (error 'no-char-for-code :code code))
  +                      (substitute-char (char)
  +                        :report "Substitute another char."
  +                        :interactive
  +                        (lambda ()
  +                          (format *query-io* "Char: ")
  +                          (list (read-char *query-io*)))
  +                        char)
  +                      (pass-code ()
  +                        :report "Pass the code to char handler."
  +                        code))))
  +                 :default-handler
  +                   (if *use-strict-json-rules*
  +                       (json-syntax-error stream esc-error-fmt "\\" c)
  +                       c))))
         (t c))))
   
   
  
positive.code: is encountered which is greater than the application's CHAR-CODE-LIMIT
  or for which CODE-CHAR returns NIL."))
  
  (defun read-json-string-char (stream)
    "Read a JSON String char (or escape sequence) from the STREAM and
  return it.  If an end of string (unescaped quote) is encountered,
  
negative.code: list."
    (cdr *accumulator*))
  
  (defun init-string-stream-accumulator ()
    "Initialize a string-stream accumulator."
    (setq *accumulator* (make-string-output-stream)))
  
  (defun string-stream-accumulator-add (char)
    "Add CHAR to the end of the string-stream accumulator."
    (write-char char *accumulator*)
    *accumulator*)
  
  (defun string-stream-accumulator-get ()
    "Return all characters accumulated so far in a string-stream
  accumulator and close the stream."
    (prog1 (get-output-stream-string *accumulator*)
      (close *accumulator*)))
  
  (defun set-decoder-simple-list-semantics ()
    "Set the decoder semantics to the following:
  