                 flow-indent (+ indent ind)]
             (if (and (zstring lloc)
                      (keyword-fn? options (zstring lloc))
-		     (not (= caller :map)))
-		     ; We could also check for (= caller :pair-fn) here,
-		     ; or at least check to see that it isn't a map.
-
-	       (if (zvector? rloc)
-              ; This is an embedded :let or :when-let or something.
-	      ; We check to see if a keyword is found in the :fn-map
-	      ; (without the :, of course) and if it is and there
-	      ; is a vector after it, we assume that it must be one of these.
-              (let [[hang-or-flow style-vec] (fzprint-hang-unless-fail
-                                               loptions
-                                               hanging-indent
-                                               flow-indent
-                                               fzprint-binding-vec
-                                               rloc)
-                    arg-1 (if (= hang-or-flow :hang)
-                            (concat-no-nil arg-1
-                                           [[(blanks hanging-spaces) :none
-                                             :whitespace 2]])
-                            arg-1)]
-                [hang-or-flow (concat-no-nil arg-1 style-vec)])
-              (let [[hang-or-flow style-vec] (fzprint-hang-unless-fail
-                                               loptions
-                                               hanging-indent
-                                               flow-indent
-                                               fzprint*
-                                               rloc)
-                    arg-1 (if (= hang-or-flow :hang)
-                            (concat-no-nil arg-1
-                                           [[(blanks hanging-spaces) :none
-                                             :whitespace 2]])
-                            arg-1)]
-                [hang-or-flow (concat-no-nil arg-1 style-vec)])
-
-
-		)
-		
-		
+                     (not (= caller :map)))
+              ; We could also check for (= caller :pair-fn) here,
+              ; or at least check to see that it isn't a map.
+              (if (zvector? rloc)
+                ; This is an embedded :let or :when-let or something.
+                ; We check to see if a keyword is found in the :fn-map
+                ; (without the :, of course) and if it is and there
+                ; is a vector after it, we assume that it must be one of these.
+                (let [[hang-or-flow style-vec] (fzprint-hang-unless-fail
+                                                 loptions
+                                                 hanging-indent
+                                                 flow-indent
+                                                 fzprint-binding-vec
+                                                 rloc)
+                      arg-1 (if (= hang-or-flow :hang)
+                              (concat-no-nil arg-1
+                                             [[(blanks hanging-spaces) :none
+                                               :whitespace 2]])
+                              arg-1)]
+                  [hang-or-flow (concat-no-nil arg-1 style-vec)])
+                (let [[hang-or-flow style-vec] (fzprint-hang-unless-fail
+                                                 loptions
+                                                 hanging-indent
+                                                 flow-indent
+                                                 fzprint*
+                                                 rloc)
+                      arg-1 (if (= hang-or-flow :hang)
+                              (concat-no-nil arg-1
+                                             [[(blanks hanging-spaces) :none
+                                               :whitespace 2]])
+                              arg-1)]
+                  [hang-or-flow (concat-no-nil arg-1 style-vec)]))
               ; Make the above if a cond, and call fzprint-hang-one?  Or
-	      ; maybe fzprint* if we are calling fzprint-hang-unless-fail,
-	      ; which I think we are.
-
+              ; maybe fzprint* if we are calling fzprint-hang-unless-fail,
+              ; which I think we are.
               ; This is a normal two element pair thing
               (let [; Perhaps someday we could figure out if we are already
                     ; completely in flow to this point, and be smarter about

                           new-param-map
                           mark-map
                           new-previous-data
                           new-out))
                (or (= (first guide-seq) :element)
                    (= (first guide-seq) :element-multi)

                             (assoc param-map :indent (first (next guide-seq)))
                             mark-map
                             previous-data
                             options
                             out))
                (= (first guide-seq) :indent-reset)
                  ; put the indent back where it was originally
