anchor.diff:                                             (factorial (digit-char-p digit-char)))))
   
   
  +(defun digit-factorial-chain (val)
  +  (loop
  +    with cur-val = (digit-factorial val)
  +    if (or (= cur-val val) (member cur-val chain :test #'=))
  +      return (values (1+ chain-length) (cons val chain) cur-val)
  +    else collect cur-val into chain
  +         and count 1 into chain-length
  +         and do (setf cur-val (digit-factorial cur-val))))
   
  +(defun euler-problem-74 (ceiling-value)
  +  (time (loop for i from 1 to ceiling-value
  +              as chain-length = (digit-factorial-chain i)
  +            when (= chain-length 60)
  +              count 1 into long-chain-count
  +              finally (return long-chain-count))))
   
  -
  -
  -
  -
  -
  -
  -
  -
  -
  -
  -
  -
  -
  -
  -
  -
  +(defun euler-74 ()
  +  (euler-problem-74 (expt 10 6)))
  
positive.code:                  as cur-value = (expt a b)
                   as cur-digit-sum = (digit-sum cur-value)
                   when (> cur-digit-sum max-digit-sum)
                     do (setf max-digit-sum cur-digit-sum)
                   )
          finally (return max-digit-sum)))
  
  (defun euler-toitent-function (val)
    (reduce #'* (slow-prime-factorization val) :key #'1-))
  
  (defun euler-problem-69 (ceiling)
    (loop for i from 2 to ceiling
  
negative.code: (defun euler-71 ()
    (numerator (euler-problem-71 (expt 10 6) 3/7)))
  
  (defun euler-problem-72 (ceiling-value)
    (loop for denominator from 2 to ceiling-value
         summing (euler-toitent-function denominator)))
  
  (defun euler-72 ()
    (euler-problem-72 (expt 10 6)))
  
  (defun euler-problem-73 (max-denominator lower-fence upper-fence)
    (loop for denom from 1 to max-denominator
  