(load "c:\\program files\\acl62\\music60.cl")

(defun make-two-part-1-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-2-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-3-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-1-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-2-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-3-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-1-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-2-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-3-UST (pair)
  (let* ((l1 (get-a-UST-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-3 l2)))
    (put-rythm-to-each-part l3)))



(defun make-two-1-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-1-UST l)) w))))


(defun make-two-2-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-2-UST l)) w))))


(defun make-two-3-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-3-UST l)) w))))


(defun make-three-1-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-1-UST l)) w))))


(defun make-three-2-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-2-UST l)) w))))

(defun make-three-3-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-3-UST l)) w))))


(defun make-four-1-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-1-UST l)) w))))


(defun make-four-2-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-2-UST l)) w))))


(defun make-four-3-UST (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-3-UST l)) w))))


(defun make-two-part-1-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-2-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-3-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-1-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-2-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-3-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-1-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-2-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-3-lhv (pair)
  (let* ((l1 (get-a-lhv-at-random-from-pair pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-1-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-1-lhv l)) w))))


(defun make-two-2-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-2-lhv l)) w))))


(defun make-two-3-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-3-lhv l)) w))))


(defun make-three-1-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-1-lhv l)) w))))


(defun make-three-2-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-2-lhv l)) w))))

(defun make-three-3-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-3-lhv l)) w))))


(defun make-four-1-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-1-lhv l)) w))))


(defun make-four-2-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-2-lhv l)) w))))


(defun make-four-3-lhv (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-3-lhv l)) w))))



(defun make-two-part-1-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-2-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-3-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-1-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-2-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-3-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-1-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-2-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-3-pt (pair)
  (let* ((l1 (get-a-pt-at-random pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-1-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-1-pt l)) w))))


(defun make-two-2-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-2-pt l)) w))))


(defun make-two-3-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-3-pt l)) w))))


(defun make-three-1-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-1-pt l)) w))))


(defun make-three-2-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-2-pt l)) w))))

(defun make-three-3-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-3-pt l)) w))))


(defun make-four-1-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-1-pt l)) w))))


(defun make-four-2-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-2-pt l)) w))))


(defun make-four-3-pt (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-3-pt l)) w))))



(defun make-two-part-1-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-2-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-3-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-1-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-2-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-3-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-1-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-2-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-3-4th (pair)
  (let* ((l1 (get-forth-interval-at-random pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-1-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-1-4th l)) w))))


(defun make-two-2-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-2-4th l)) w))))


(defun make-two-3-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-3-4th l)) w))))


(defun make-three-1-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-1-4th l)) w))))


(defun make-three-2-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-2-4th l)) w))))

(defun make-three-3-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-3-4th l)) w))))


(defun make-four-1-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-1-4th l)) w))))


(defun make-four-2-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-2-4th l)) w))))


(defun make-four-3-4th (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-3-4th l)) w))))


(defun make-two-part-1-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-2-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-two-part-3-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-two-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-1-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-2-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-three-part-3-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-three-parts-3 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-1-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair)) 
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-1 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-2-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-2 l2)))
    (put-rythm-to-each-part l3)))


(defun make-four-part-3-chord (pair)
  (let* ((l1 (chord-tone pair))
         (l2 (remove (car (avoid-note pair))
             (connect-lists-for-c-point l1)))
         (l3 (divide-a-list-into-four-parts-3 l2)))
    (put-rythm-to-each-part l3)))



(defun make-two-1-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-1-chord l)) w))))


(defun make-two-2-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-2-chord l)) w))))


(defun make-two-3-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-two-part-3-chord l)) w))))


(defun make-three-1-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-1-chord l)) w))))


(defun make-three-2-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-2-chord l)) w))))

(defun make-three-3-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-three-part-3-chord l)) w))))


(defun make-four-1-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-1-chord l)) w))))


(defun make-four-2-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-2-chord l)) w))))


(defun make-four-3-chord (pairs)
  (do ((lst pairs (cdr lst))
       (w))
      ((null lst) (reverse w))
    (let ((l (car lst)))
      (push (list l (make-four-part-3-chord l)) w))))