; http://www.cap-lore.com/code/Scheme/rc4.html
(let (
     ;  (ex (lambda (m e) (write (list m e))(newline) e))
       (Do ((fileVal "Do") 'Do)))
(lambda (sy key)
    (let ((nb (let ((s (make-string 256))(i 0)(j 0))
 (Do 256 (lambda(n) (string-set! s n (integer->char n))))
 (let ((len (string-length key))(j 0))
   (Do 256 (lambda (k) (let ((i (- 255 k)))
     (set! j (modulo (+ j (char->integer (string-ref s i))
        (char->integer (string-ref key (modulo i len)))) 256))
     (let ((t (string-ref s i))) (string-set! s i (string-ref s j))
       (string-set! s j t))))))
   (lambda ()
   (set! i (if (= i 255) 0 (+ i 1)))
    (let* ((a (string-ref s i))(A (char->integer a)))
      (set! j (modulo (+ j A) 256))
      (let* ((b (string-ref s j))(B (char->integer b)))
        (string-set! s i b)(string-set! s j a)
       (char->integer (string-ref s (modulo (+ A B) 256)))))))))

 (cdr (assq sy (list
  (cons 'nb (lambda (n)(let ((v 0)) (Do n (lambda (dm)
         (set! v (+ (* 256 v) (nb))))) v)))
  (cons 'sb nb)

  (cons 'rbi (lambda (n) ; random big integer less than n
   ; recursive function that returns a sufficiently large array
   (let* ((a (let ma ((as 0)(n (- n 1))) (if (= n 0) (make-vector as)
             (let ((nv (ma (+ as 1) (quotient n 256))))
             (vector-set! nv as (modulo n 256)) nv))))
         (vl (vector-length a))
         (fm (let pc ((p 1))(if (< (vector-ref a (- vl 1)) p) p (pc (+ p p))))))
   ;  (write (list 'dope vl (pt hd) n a hd))(newline)
    (lambda () (let sr () (let cd
       ((v 0)(ix vl)(td (lambda () (modulo (nb) fm)))(rn #f))
  ;  (write (list 'inter v ix lim fm))(newline)
    (if (= ix 0) v (let ((td (td))(lim (vector-ref a (- ix 1))))
    (if (or rn (< td lim)) (cd (+ td (* 256 v)) (- ix 1) nb #t)
    (if (= td lim) (cd (+ td (* 256 v)) (- ix 1) nb #f) (sr)))))))))))))))))

; tests

(let ((n 9826398458765698373982)) (let ((DoL ((fileVal "Do") 'DoL))
   (g (((fileVal "RC4") 'rbi "Seed text") n)))
   (DoL 10 (lambda (j) (g)))))

(let sm ((w al)(s 0)) (if (null? w) s (sm (cdr w) (+ (let ((r (car w))) (* r r)) s))))

(let ((n 255)) (let ((Do ((fileVal "Do") 'Do))
   (a (make-vector n 0))
   (g (((fileVal "RC4") 'rbi "Seed text2") n)))
   (Do (expt 2 17) (lambda (j) (let ((x (g))) (vector-set! a x (+ 1 (vector-ref a x))))))
   a))
 