anchor.diff:    "Gets the age of a node"
     (- *current-game* (node-birth-game node)))
   
  +;; Executes a prunning in a tree
  +;; Function doesn't work properly
   (defun tree-pruning(tree)
     "Pruning depending on the age and score of the nodes"
     (let ((score (node-score tree)) (age (node-age tree)))
  -    (if(and (> age *pruning-min-age*) (< (/ score age) *pruning-treshold*))
  +    (if(and (> age *pruning-min-age*) (< (/ score age) *pruning-threshold*))
          (progn 
  -        ;; (format t "EXECUTING PRUNING")
  +        ;;(format t "EXECUTING PRUNING")
            (setf (tree-node-left-child tree) nil)
            (setf (tree-node-right-child tree) nil))
          (when (and 
  
positive.code: ;; Function to get the root of a tree
  (defun get-root()
    (make-tree-node :data (make-node-data :score 0.0 :game-number 0 :lower-bound 0.0 :upper-bound 1.0)))
  
  ;; Gets the root of the tree for the current node based on its ancestors
  ;; Incorrect function. Doesn't work :(
  (defun find-root(node)
    (if(eq (tree-node-parent node) nil)
       node
       (find-root (tree-node-parent node))))
  
  ;; Function to initialize the sensory channels for the agent
  (defun init-sensory-channels()
  
negative.code:   "pruning for the feature-detectors (channels) of the agent"
    (loop for fd in feature-detectors do
         (tree-pruning (sensory-channel-discrimination-tree fd)))
    ;;(print-agent-feature-detectors-size feature-detectors)
    feature-detectors)
  
  ;; Recursive computation of the size of a tree
  (defun tree-size(tree)
    "Returns the size of a tree based on its sub nodes"
    (let ((size 1))
      (when(and (eq (tree-node-left-child tree) nil) (eq (tree-node-right-child tree)nil))
        (return-from tree-size 1))
      (setq size (+ size (tree-size (tree-node-left-child tree))))
      (setq size (+ size (tree-size (tree-node-right-child tree))))
      size))
  
  (defun print-agent-feature-detectors-size(feature-detectors)
    (when (> *verbose-level* 1)
      (loop for fd in feature-detectors do
           (format t "Feature ~s size: ~d. " (sensory-channel-feature-name fd) (tree-size (sensory-channel-discrimination-tree fd))))
      (format t "~C" #\linefeed))
    (when (> *verbose-level* 0)
      (let ((size 0))
        (loop for fd in feature-detectors do
             (setq size (+ size (tree-size (sensory-channel-discrimination-tree fd)))))
        (format t "Total size of trees: ~d ~C" size #\linefeed)))
    )
  
  ;;Prints a running average
  (defun print-discriminatory-success()
    (when (> *verbose-level* 0)
      (let ((span (floor (+ *moving-avg-span* (* *moving-avg-increase-rate* *current-game*)))) (avg 0))
        (when (< (- *current-game* 1) span)
          (setq span (- *current-game* 1)))
        (loop for i from 0 below span do
             (setq avg (+ avg (aref *success-log* (- (- *current-game* 1) i)))))
        (setq avg (* (/ avg span) 100.0))
        ;;(format t "~s ~C" *success-log* #\linefeed)
        (format t "Success rate: ~d % ~C" avg #\linefeed))))
  
  ;; Function to run a single discrimination game
  (defun run-single-game(agent &optional print)
  