(lambda (zer? zer one QR -) (lambda (a b)
(let egcd ((a a) (b b)) (if (zer? b) (cons one zer)) (let*
((qr (QR a b)) (q (car qr)) (r (cdr qr)))
   (if (zer? r) (cons zer one) (let ((c (egcd b r))) (cons (cdr c) (- (car c) (* (cdr c) q)))))))))

; test
(define (rv m v) (write (list m v)) (newline) v)
(define 2egcd ((fileVal "gegcd") zero? 0 1
  (lambda (n d) (let ((q (quotient n d))) (cons q (- n (* q d))))) -))
(define (t p q) (let ((y (2egcd p q))) (+ (* p (car y)) (* q (cdr y)))))

(define X (let ((copy (lambda (v n) (let ((nv (make-vector n)))
    (let L ((j 0)) (if (= j n) nv (begin (vector-set! nv j (vector-ref v j)) (L (+ j 1)))))))))
 ((fileVal "gegcd")
  (lambda (p) (let l ((n (vector-length p))) (or (= n 0)
    (and (zero? (vector-ref p (- n 1))) (l (- n 1))))))
  (make-vector 0) (make-vector 1 1)
  (lambda (n d) (let* ((ln (vector-length n))(n (copy n ln))(ld (vector-length d)))
    (if (< ln ld) (cons (make-vector 0) n) (let* (
    (la (+ 1 (- ln ld)))(an (make-vector la))
    (d (if (= 1 (vector-ref d 0)) d (let ((nd (make-vector ld))(r (/ (vector-ref d 0)))) 
       (let L ((j 0)) (if (= j ld) nd
         (begin (vector-set! nd j (* r (vector-ref d j))) (L (+ j 1)))))))))
 (write (list 'go ln n ld d)) (newline)
       (rv 'dnr (let L ((j 0)) (rv (list 'dnq j la) (if (= j la) (rv 'ree (cons an (copy (- n 1) ld)))
      (begin (vector-set! an j (rv 'bo (vector-ref n j)))
        (let l ((k 1)) (if (= k ld) (cons an n) (begin (vector-set! n (+ j k)
           (- (vector-ref n (+ j k)) (* (vector-ref n k) (vector-ref d j))))
           (l (+ k 1))))) (L (+ j 1)))))))))))
  (lambda (a b) (write "Poo")(newline)(/ 0)))))

(X #(1 2 1) #( 1 1))