anchor.diff:                                      d
                                       (+ t 1))
                                 (values a b c d e))))
  -                     (_ (print "round 2:"))
  -                     (a b c d e
  +                     (a b c d e ; round 2
                           (let loop ((a a) (b b) (c c) (d d) (e e) (t 20))
  -                           (print "abcde " a " " b " " c " " d " " e)
                              (if (< t 40)
  -                              (loop (band #xFFFFFFFF
  +                              (loop (->32
                                             (+ (rol 5 a)
                                                (XOR b c d)
                                                e
  
positive.code:                               (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)))))))))
  
  (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)))))))))))
  
  ;            0         1         2         3         4         5
  (print (base64
  ;   (sha1-digest "12345678901234567890123456789012345678901234567890")))
     (sha1-digest "DgH3uuAMD6YVe1XYEfyaqQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11")))
  ;(print (base64 '(49 49 49)))
     
  
negative.code:                                     d
                                      (+ t 1))
                                (values a b c d e))))
                       (a b c d e ; round 3
                          (let loop ((a a) (b b) (c c) (d d) (e e) (t 40))
                             (if (< t 60)
                                (loop (->32
                                            (+ (rol 5 a)
                                               (OR (band b c) (band b d) (band c d))
                                               e
  