(lambda (zer? zer one QR - * rv) (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 (rv (list 'qwwe a b r) (zer? r)) (cons zer one) (let ((c 
   (rv 'wr (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))))) - * rv))
(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))))))))
(c (lambda (a b) (write "Poo")(newline)(/ 0))))
 ((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* (
    (lq (+ 1 (- ln ld)))(q (make-vector lq))
    (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 lq) (if (rv 'b2 (= (rv 'tp j) lq)) (rv 'ree (cons q (rv 'cpr (copy n (rv 'ci (- ld 1))))))
      (begin (vector-set! q j (rv 'bo (vector-ref n j)))
        (let l ((k 1)) (if (rv 'bol (= k ld)) 0 (begin (vector-set! n (+ j k)
           (- (vector-ref n (+ j k)) (rv 'pd (* (vector-ref n k) (vector-ref d j)))))
           (l (+ k 1))))) (L (+ j 1)))))))))))
  (lambda (a b) (let* ((la (vector-length a)) (lb (vector-length b)) (r (make-vector la))(d (- la lb)))
  (if (< la lb) (begin (write (list "Poo" la lb)) (newline) (/ 0))
     (let L ((j 0)) (if (= j la) r (begin (vector-set! r j (- (vector-ref b j) (vector-ref a (- j d)))) (L (+ j 1))))))))
  (lambda (a b) (let* ((la (vector-length a)) (lb (vector-length b)) (lp (- (+ la lb) 1)) (p (make-vector lp 0)))
    (let L ((j 0)) (if (= j la) 0 (begin (let L ((k 0)) (if (= k lb) 0 (begin (vector-set! p (+ j k)
       (+ (vector-ref p (+ j k)) (* (vector-ref a j) (vector-ref b k)))) (L (+ k 1))))) (L (+ j 1))))) p))
  rv)))

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

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