(let ((sg ((fileVal "RND") "frSeed"))) (let r ((n 3000) (m 0) (s 0))
  (if (zero? n) (cons m s) (let ((w (sg))) (r (- n 1) (+ m w) (+ s (* w w)))))))

2000 good
2500 good bad
3000 bad

(let r ((n 25000)(s 0)) (if (= 0 n) s (r (- n 1) (+ s (* n n)))))

(let ((sg ((let  ((v (fileVal "RC4"))(sc (/ 1. (expt 2 55))))
(lambda (S) (let* ((f #f)(v (v 'nb S))(m 0)(gf (lambda () (- (* (v 7) sc) 1))))
    (lambda () (if f (begin (set! f #f) m)
      (let xx () (let* ((x (gf))(y (gf))(s (+ (* x x)(* y y))))
      (if (> s 1.) (xx) (let ((r (sqrt (/ (* -2 (log s)) s))))(set! m (* x r))
            (set! f #t) (* y r)))))))))) "frSeed"))) (let r ((n 3000) (m 0) (s 0))
  (if (zero? n) (cons m s) (let ((w (sg))) (r (- n 1) (+ m w) (+ s (* w w)))))))


(let ((sg ((let  ((v (let (
     ;  (ex (lambda (m e) (write (list m e))(newline) e))
       (Do ((let* (
(Do  (lambda (n p) (let Do ((n n)) (if (> n 0) (let ((u (- n 1))) (p u) (Do u))))))
(DoL (lambda (n p) (let l ((v '())(n (- n 1))) (if (< n 0) v (l (cons (p n) v)(- n 1))))))
(DoV (lambda (n p) (let ((v (make-vector n))) (Do n (lambda (j) (vector-set! v j (p j)))) v))))

(lambda (sy) (cdr (assq sy (list (cons 'Do Do) (cons 'DoL DoL)(cons 'DoV DoV))))))
 'Do)))
(lambda (sy key) (let ((nb (let ((s (make-string 256)))
  (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 (bitwise-and (+ j (char->integer (string-ref s i))
          (char->integer (string-ref key (modulo i len)))) 255))
      (let ((t (string-ref s i))) (string-set! s i (string-ref s j))
        (string-set! s j t))))))
 (let ((i 0)(j 0)) (lambda () (set! i (bitwise-and (+ i 1) 255))
    (let* ((a (string-ref s i))(A (char->integer a)))
      (set! j (bitwise-and (+ j A) 255))
      (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 (bitwise-and (+ A B) 255))))))))))

 (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 (bitwise-and n 255)) 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))))))))))))))))))
(sc (/ 1. (expt 2 55))))
(lambda (S) (let* ((f #f)(v (v 'nb S))(m 0)(gf (lambda () (- (* (v 7) sc) 1))))
    (lambda () (if f (begin (set! f #f) m)
      (let xx () (let* ((x (gf))(y (gf))(s (+ (* x x)(* y y))))
      (if (> s 1.) (xx) (let ((r (sqrt (/ (* -2 (log s)) s))))(set! m (* x r))
            (set! f #t) (* y r)))))))))) "frSeed"))) (let r ((n 3000) (m 0) (s 0))
  (if (zero? n) (cons m s) (let ((w (sg))) (r (- n 1) (+ m w) (+ s (* w w)))))))