anchor.diff:  (defun poly* (poly1 poly2)
     (make-poly (terms* (terms poly1) (terms poly2))))
   
  -(defun make-poly terms
  -  (list 'poly (polyreduce (sort-by-order terms))))
  +(defun make-term (coeff . vars)
  +  (list 'term coeff (sort-by-sym vars)))
   
  -(defun terms (poly) (cadr poly))
  +(defun coeff (term) (cadr term))
  +(defun vars (term) (caddr term))
   
  -(defun polyreduce (terms)
  -  (cond ((null terms) '())
  -        ((same-orderp (car terms) (cadr terms))
  -         (cons (term+ (car terms) (cadr terms))
  -               (polyreduce (cddr terms))))
  -        (t (cons (car terms) (polyreduce (cdr terms))))))
  -
  -(defun same-orderp (term1 term2)
  -  (equal (vars term1) (vars term2)))
  +(defun sort-by-sym (vars)
  +  (qsort vars sym->val))
   
   (defun terms* (terms1 terms2)
     (reduce poly+ (terms*-inner terms1 terms2)))
  
positive.code: (defun term* (term1 term2)
    (make-term (* (coeff term1) (coeff term2)) (vars* (vars term1) (vars term2))))
  
  (defun vars* (vars1 vars2)
    (cond ((and (null vars1) (null vars2)) '())
          ((or (null vars1) (null vars2)) (or vars1 vars2))
  
negative.code:          (cons (car vars1) (vars* (cdr vars1) vars2)))
          ((> (sym->val (sym (car vars1))) (sym->val (sym (car vars2))))
           (cons (car vars2) (vars* vars1 (cdr vars2))))
          (t (cons (make-var (sym (car vars1)) (+ (pwr (car vars1)) (pwr (car vars2))))
                   (vars* (cdr vars1) (cdr vars2))))))
  
  (defun sym->val (sym)
    (convert sym <string>))
  