lisp hash symbol replaces returned values

Question

I've been trying to build something similar to a breadth-first tree-like structure for a graph, which contains all possible paths from a given node. I didn't have problem with the algorithm as much as I do with some sort of error that pops up. Here's the relevant code below:

(set 'my-graph '((A (B C))
                 (B (D E))
                 (C (F G))
                 (D (E))
                 (E (H))
                 (F (H I))
                 (G (I))
                 (H (J))
                 (I (J))
                 (J ())))


(defun search-tree(graph traversed visited)
  (cond
   ((null traversed) NIL)
   (:else (let*
              ((new-visited (append visited (list (car traversed))))
               (children (add-children graph (car traversed)
                                       (append (cdr traversed) new-visited))))
            (cond
             ((null children) (list (car traversed)))
             (:else 
              (cons (car traversed)
                    (mapcar (lambda(x) (search-tree graph (list x) new-visited)) children)))
             )
            )
          )
   )
  )

;;; Selects the node to pick returned children from
(defun add-children(graph node visited)
  (cond
   ((null graph) NIL)
   ((equal (caar graph) node) (new-nodes (cadar graph) visited))
   (:else (add-children (cdr graph) node visited))
   )
  )

;;; Returns new, unvisited nodes from the children of a node
(defun new-nodes(children visited)
  (cond
   ((null children) NIL)
   ((member (car children) visited) (new-nodes (cdr children) visited))
   (:else (cons (car children) (new-nodes (cdr children) visited)))
   )
  )

Function search tree is called as (search-tree my-graph '(A) '()) and it returns almost everything as I want correctly, but the first terminal node which is replaced with a # symbol (it should be (J)). What could be the problem in here?
That's the returned value.
(A (B (D (E (H #))) (E (H (J)))) (C (F (H (J)) (I (J))) (G (I (J)))))
I've tried tracing the code, but I still don't understand why is the (J) list swapped in mid-recursion with a # symbol.

Answer 1

Usually I would guess that it has something to do with *print-level*.

This variable controls how deep nested lists are printed. Set it to a number for the level. Lists in a deeper level are replaced with a # character.

If setting that to NIL does not help, then you might also want to consult the Allegro CL manual - I can remotely remember that the IDE also has its own settings.