anchor.diff:  (defconstant +nursery-size+ (* +word-size+ (expt 2 12)))
   
   ;;; In each thread, this variable gets bound to a vector that contains
  -;;; the youngest generation objects.  An object takes up at least two
  -;;; words in the nursery, and objects are aligned on a double-word
  -;;; boundary.
  +;;; the youngest generation objects (the nursery).  An object takes up
  +;;; at least two words in the nursery, and objects are aligned on a
  +;;; double-word boundary.
   (defvar *nursery*)
   
  -;;; In each thread, this variable gets bound to a vector of words.
  -;;; The length of the vector is (/ +nursery-size+ +word-size 2).  Each
  -;;; word is an unsigned integer, but it represents a bitvector, that
  -;;; contains liveness information of the objects in the nursery.  The
  -;;; word at index i of the vector represents the objects at indexes
  -;;; between (* 2 +word-size+ i)) and (1- (* 2 +word-size+ (1+ i))).
  -;;; When the bit (ash 1 k) is set in word i, then the two consecutive
  -;;; words at indexes m and m+1 in the nursery are free, where m can be
  -;;; expressed as (* 2 (+ (* +word-size+ i) k)).  By doing it this way,
  -;;; we can use integer-length to find the most significant bit that is
  -;;; set in a word, and thus the corresponding free word with the
  +;;; In each thread, this variable gets bound to a bitvector (though
  +;;; not represented as a common Lisp bitvecto).  The representation is
  +;;; as follows: we use a vector of words.  The length of the vector is
  +;;; (/ +nursery-size+ +word-size 2), so to each bit in the bitvector
  +;;; corresponds a pair of wrds in the nursery.  Each word if the
  +;;; bitvector is a +word-size+ unsigned integer, representing liveness
  +;;; information for +word-size+ consecutive double words in the
  +;;; nursery.  The word at index i of the bitvector vector represents
  +;;; the objects at indexes between (* 2 +word-size+ i)) and (1- (* 2
  +;;; +word-size+ (1+ i))) in the nursery.  When the bit (ash 1 k) is
  +;;; set in word i, then the two consecutive words at indexes m and m+1
  +;;; in the nursery are free, where m can be expressed as (* 2 (+ (*
  +;;; +word-size+ i) k)).  By doing it this way, we can use
  +;;; integer-length to find the most significant bit that is set in a
  +;;; word, and thus the corresponding free word in the nursery with the
   ;;; highest index.
   (defvar *nursery-live*)
   
  
positive.code: 			      (1+ i)
  			      i))))
      (aref nursery (- i size))))
    
  	 
  	     
  
  ;;; In each thread, this variable gets bound to the address of element
  ;;; zero of the nursery. 
  
negative.code: ;;; generation, we move A and its transitive closure to an older
  ;;; generation.
  
  ;;; We trace the live objects and we obtain a bitvector (though not
  ;;; represented as a Common Lisp bitvector) of information about what
  ;;; words in the nursery are live and what words are dead.  We want to
  ;;; compact the nursery by "sliding" the live objects towards lower
  ;;; indexes of the nursery.  Since we are moving objects, any address
  ;;; that points to an object in the nursery that is going to be moved
  ;;; needs to be modified to reflect the motion.  The amount that an
  ;;; object is moved is determined by the total free space before it in
  ;;; the nursery.
  
  (defconstant +word-size+ 64)
  
  