anchor.diff:                                (values a b c d e)))))
                                 
                     (main (+ i 1)
  -                     (band #xFFFFFFFF (+ A a))
  -                     (band #xFFFFFFFF (+ B b))
  -                     (band #xFFFFFFFF (+ C c))
  -                     (band #xFFFFFFFF (+ D d))
  -                     (band #xFFFFFFFF (+ E e)))))))))
  +                     (->32 (+ A a))
  +                     (->32 (+ B b))
  +                     (->32 (+ C c))
  +                     (->32 (+ D d))
  +                     (->32 (+ E e)))))))))
   
  -(define (base64 L)
  -(let ((alpha "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"))
  -   (let*((len (length L))
  -         (p (div len 3))
  -         (q (mod len 3)))
  -      (runes->string
  -      (let loop ((i 0))
  -         (let*((c0 (if (< i len) (list-ref L i) 0))
  -               (i (+ i 1))
  -               (c1 (if (< i len) (list-ref L i) 0))
  -               (i (+ i 1))
  -               (c2 (if (< i len) (list-ref L i) 0))
  -               (i (+ i 1))
  -               (q (- i len))
  -               (u (OR
  -                     (<< c0  16)
  -                     (<< c1   8)
  -                     (<< c2   0))))
  -            (print "i: " i)
  -            (print "q: " q)
  -            (cons 
  -            (string-ref alpha       (>> u 18)    )
  -            (cons
  -            (string-ref alpha (band (>> u 12) 63))
  -            (cons
  -            (if (> q 1) #\=
  -            (string-ref alpha (band (>> u  6) 63)))
  -            (cons
  -            (if (> q 0) #\=
  -            (string-ref alpha (band     u     63)))
  -            (if (< i len) (loop i) null)))))))))))
  +(define (->string value)
  +   (runes->string
  +   (let ((L "0123456789abcdef"))
  +   (let loop ((v value))
  +      (if (null? v) null
  +      (cons
  +         (string-ref L (>> (car v) 4))
  +         (cons
  +         (string-ref L (band (car v) #xF))
  +            (loop (cdr v)))))))))
   
  -;            0         1         2         3         4         5
  -(print (base64
  -;   (sha1-digest "12345678901234567890123456789012345678901234567890")))
  -   (sha1-digest "DgH3uuAMD6YVe1XYEfyaqQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11")))
  -;(print (base64 '(49 49 49)))
  +; examples:
  +(define (example message)
  +   (print message " ==> " (->string (sha1:digest message))))
      
  +(example "Hello, Lisp!")
  +(example "abc")
  +(example "Night
  +THE sun descending in the west  
  +The evening star does shine; 
  +The birds are silent in their nest.
  + 
  +And I must seek for mine.")
  +(example "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu")
  
positive.code:                (list (word->list A) (word->list B) (word->list C) (word->list D) (word->list E)))
              (let*((message (substring padded-message (* i 64) (+ (* i 64) 64)))
                    (W (message->words message)))
                 (let*((a b c d e
                          (let loop ((a A) (b B) (c C) (d D) (e E) (t 0))
                             (print "abcde " a " " b " " c " " d " " e)
                             (if (< t 20)
                                (loop (band #xFFFFFFFF
                                            (+ (rol 5 a)
                                               (OR (band b c) (band (~ b) d))
                                               e
                                               (list-ref W t)
                                               (list-ref K 0)))
  
negative.code:                                     d
                                      (+ t 1))
                                (values a b c d e))))
                       (a b c d e ; round 4
                          (let loop ((a a) (b b) (c c) (d d) (e e) (t 60))
                             (if (< t 80)
                                (loop (->32
                                            (+ (rol 5 a)
                                               (XOR b c d)
                                               e
  