(define (detree tr)                                                                                              
  (define (inner t)                                                                                              
    (print t)                                                                                                    
    (cond ((Neg? t) (if (not (num-or-var? (second t))) (inner (second t))))                                      
          ((or (Dis? t) (Gen? t))                                                                                
           (let ((tf (map (lambda (x) (num-or-var? x))                                                           
                     (list (second t) (third t)))))                                                              
             (if (any? tf)                                                                                       
               (map (lambda (p) (if (first p) (inner (second p))))                                               
                    (zip tf (cdr t)))))                                                                          
                    )                                                                                            
          (else t)))                                                                                             
  (append tr (inner tr)))