       (let ((end (point)))
         (backward-word 1)
         (forward-word 1)
+        (goto-char (min end (point)))
         (let* ((parse-state (paredit-current-parse-state))
                (state
                 (paredit-kill-word-state parse-state 'char-before)))
-          ;++ Hack: Move past the start regardless of whether there was
-          ;++ a state change, so that we can unconditionally move back
-          ;++ by one character afterward.
-          (while (and (<= (point) end)
-                      (not (eobp))
+          (while (and (< (point) end)
                       (progn
                         (setq parse-state
                               (parse-partial-sexp (point) (1+ (point))
                                                   nil nil parse-state))
-                        (eq state
-                            (paredit-kill-word-state parse-state
-                                                     'char-before)))))
+                        (or (eq state
+                                (paredit-kill-word-state parse-state
+                                                         'char-before))
+                            (progn (backward-char 1) nil)))))
           (if (and (eq state 'comment)
-                   (eq ?\# (char-before (point)))
-                   (eq ?\| (char-before (1- (point)))))
-              (backward-char 1))
-          (backward-char 1))))          ;Back up before state change.
+                   (eq ?\# (char-after (point)))
+                   (eq ?\| (char-before (point))))
+              (backward-char 1)))))
   (backward-kill-word 1))
  
-;;; Word-Killing Auxiliaries
+;;;;;; Word-Killing Auxiliaries
 
 (defun paredit-kill-word-state (parse-state adjacent-char-fn)
   (cond ((paredit-in-comment-p parse-state) 'comment)

         ((paredit-gnu-emacs-p)
          (lambda ()
            (and mark-active transient-mark-mode)))))

;;;;; S-expression Parsing Utilities

             (paredit-in-comment-p))
         (insert close))
        ((not (paredit-in-char-p))
         (paredit-move-past-close-and-reindent close)
         (paredit-blink-paren-match nil))))

(defun paredit-move-past-close-and-newline (close)
  (if (or (paredit-in-string-p)
          (paredit-in-comment-p))
      (insert close)
    (if (paredit-in-char-p) (forward-char))
    (paredit-move-past-close-and-reindent close)
    (let ((comment.point (paredit-find-comment-on-line)))
      (newline)
      (if comment.point
          (save-excursion
            (forward-line -1)
            (end-of-line)
            (indent-to (cdr comment.point))
            (insert (car comment.point)))))
    (lisp-indent-line)
    (paredit-ignore-sexp-errors (indent-sexp))
    (paredit-blink-paren-match t)))

(defun paredit-find-comment-on-line ()
  "Find a margin comment on the current line.
Return nil if there is no such comment or if there is anything but
  whitespace until such a comment.
If such a comment exists, delete the comment (including all leading
  whitespace) and return a cons whose car is the comment as a string
  and whose cdr is the point of the comment's initial semicolon,
  relative to the start of the line."
  (save-excursion
    (paredit-skip-whitespace t (point-at-eol))
    (and (eq ?\; (char-after))
         (not (eq ?\; (char-after (1+ (point)))))
         (not (or (paredit-in-string-p)
                  (paredit-in-char-p)))
         (let* ((start                  ;Move to before the semicolon.
                 (progn (backward-char) (point)))
                (comment
                 (buffer-substring start (point-at-eol))))
           (paredit-skip-whitespace nil (point-at-bol))
           (delete-region (point) (point-at-eol))
           (cons comment (- start (point-at-bol)))))))

(defun paredit-insert-pair (n open close forward)
  (let* ((regionp
          (and (paredit-region-active-p)
               (paredit-region-safe-for-insert-p)))
         (end
          (and regionp
               (not n)
               (prog1 (region-end) (goto-char (region-beginning))))))
    (let ((spacep (paredit-space-for-delimiter-p nil open)))
      (if spacep (insert " "))
      (insert open)
