anchor.diff:      (loop :for start := 0 :then (1+ i)
             :for i := (position #\} (line-string p) :start start)
             :while i
  -          :do
  -          (unless (let ((p (character-offset (line-start p) i)))
  +          :do (unless (let ((p (character-offset (line-start p) i)))
                           (check-type p point)
                           (in-string-or-comment-p p))
  -                (return t)))))
  +                (return i)))))
   
   (defun unbalanced-p (state)
     (if (member #\( (pps-state-paren-stack state)) t nil))
  
positive.code:         (character-offset p (length word))
          (skip-whitespace-forward p t))
        (with-point ((start p))
          (cond
            ((unbalanced-p (setf state
                                 (parse-partial-sexp (copy-point start :temporary)
                                                     (line-end p))))
             (setf unbalanced-flag t)
             (unless (setf state (unbalanced-indent p indent start))
               (return-from c-indent-line nil)))
            ((and word (ppcre:scan "^(?:case|default)$" word))
             (%indent p (- indent tab-width)))
            (t
             (%indent p indent)
             (unless (indent-cond-op p indent)
               (return-from c-indent-line nil)))))
        (when (eql #\{ (car (pps-state-paren-stack state)))
          (let ((indent (+ indent tab-width))
                (status))
  
negative.code:                   (return-from c-indent-line nil)))
      (when (eql #\# (character-at p))
        (%indent p 0))
      (when (eql #\} (character-at p))
        (character-offset p 1)
        (skip-whitespace-forward p t))
      (alexandria:when-let ((i (end-block-line-p p)))
        (with-point ((p p)
                     (start p))
          (line-start start)
          (character-offset (line-start p) (1+ i))
          (when (> 0 (pps-state-paren-depth (parse-partial-sexp start p)))
            (decf indent tab-width))))
      (let ((word (looking-at p "\\w+"))
            (state)
            (unbalanced-flag nil))
  