         param-map (if (or comment? (and previous-comment? newline?))
                     param-map
                     (dissoc param-map :spaces))]
-    (dbg-s options
-           :guide
-           "guided-output: ------ incoming out:"
-           #_out
-           ((:dzprint options) {} (into [] out)))
+    (dbg-s
+      options
+      :guide
+      "guided-output: ------ incoming out:"
+      #_out
+      ((:dzprint options)
+        {}
+        (into []
+              #_out
+              (let [out-len (count out)
+                    out-drop (int (* 0.8 out-len))
+                    out-drop
+                      (if (< (- out-len out-drop) 10) (- out-len 10) out-drop)]
+                #_(concat [(str "dropped " out-drop " elements")]
+                          (drop out-drop out))
+                (condense-depth 1 out)))))
     (dbg-s-pr options :guide "guided-output; ------ next-guide:" next-guide)
     (dbg-s options
            :guide
            "guided-output: ------ next-seq:"
-           ((:dzprint options) {} next-seq))
+           ((:dzprint options) {} (condense-depth 1 next-seq)))
     (dbg-s-pr options :guide "guided-output: ------ mark-map:" mark-map)
     ;"(first cur-seq)" (first cur-seq)
     (dbg-s

      (if (and (= caller (first debug-vector))
               (= (:depth options) (second debug-vector)))
        (nth debug-vector 2)))))

;;
;; # Use pmap when we have it

                                 (+ indent ind))
                               1)
                             #_1))) :none :whitespace 25]]
                   next-seq)
                 ; This might be nil, but that's ok
                 next-seq)
               (if newline?
                 (concat-no-nil
                   ; If we have excess-guided-newline-count, then
                   ; output it now.  These newlines have no spaces
                   ; after them, so they should not be used to start
                   ; a line with something else on it!  We dec because
                   ; the next thing is a guarenteed newline.
                   (if (and excess-guided-newline-count
                            (pos? (dec excess-guided-newline-count)))
                     (repeat (dec excess-guided-newline-count)
                             ["\n" :indent 22])
                     :noseq)
                   [[(str "\n"
                          #_(blanks
                              ; Figure out what the next thing is
                              ; If this is a pair, that's a bit dicey?
                              (let [next-seq-next (first (next cur-seq))
                                    newline-next?
                                      (when next-seq-next
                                        (= (nth (first next-seq-next) 2)
                                           :newline))]
                                ; If the next thing is a newline,
                                ; don't put any blanks on this line
                                (if newline-next? 0 (dec new-ind))))) :none
                     :indent 21]])
                 ; This doesn't fit, and isn't a newline
                 ; Do we need a newline, or do we already have one
                 ; we could use?
                 ;
                 ; This will be a problem, as the simple case says
                 ; "Sure, we can use a guided newline here."
                 ; Don't let a comment come after a guided-newline
                 (if (and previous-newline?
                          (not (and comment? previous-guided-newline?)))
                   ; We have just done a newline that we can use.
                   #_(concat-no-nil [[" " :none :whitespace 16]] next-seq)
                   (concat-no-nil
                     [[(blanks (if previous-newline? #_ind (+ indent ind) 1))
                       #_" " :none :whitespace 16]]
                     next-seq)
                   ; Do we already have a newline at the beginning of a bunch
                   ; of
                   ; output?
                   (if indent?
                     ; Yes, don't prepend another newline
                     next-seq
                     (prepend-nl options (+ indent ind) next-seq)))))]
       (dbg-s
         options
         :guide
         "guided-output returned additional out:"
         ((:dzprint options) {} (into [] (condense-depth 1 guided-output-out))))
       (concat out guided-output-out))]))

(defn comment-or-newline?
  "Is this element in the output from fzprint-seq a comment or a newline?"
