;;; (((XLISP 3.3))
;;; FOUR EVER MORE

(define-macro (cw &rest z) (list 'quasiquote z))

(define-macro (pr &rest args) (cons 'prn args))

(define-macro (prnt exp &rest j) (cw begin (newline) (display '--------------------) (newline) (elist (quote ,exp)) (newline) (display '-------result-------) (newline) (elist ,exp) (newline)))

(define-macro (prn exp j) (cw if ((n==== ,exp) (quote ,j)) (begin (prnt ,exp) (display '------expected------) (newline) (elist (quote ,j)) (newline))))

(define sp 32)

(define (elist exp) (if (list? exp) (let ((sp (sy 32))) (display (sy 40)) (display sp) (for-each (lambda (x) (write x) (display sp) (display (sy 44)) (display sp)) exp) (display (sy 41))) (write exp)))

(define a 'a) (define b 'b) (define c 'c) (define d 'd) (define e 'e) (define f 'f) (define g 'g) (define h 'h) (define i 'i) (define j 'j) (define k 'k) (define l 'l) (define m 'm) (define n 'n) (define o 'o) (define p 'p) (define q 'q) (define r 'r) (define s 's) (define t 't) (define u 'u) (define v 'v) (define w 'w) (define x 'x) (define y 'y) (define z 'z)

(define-macro (mark &rest r) r)

(define-macro (av x) (cw apply values ,x))

(define-macro (abc e1 e2) (cw multiple-value-bind (a b c d e f g h i j k l m n o p q r s t u v w x y z) ,e1 ,e2))

(define-macro (vaz e1 e2) (cw multiple-value-bind (va vb vc vd ve vf vg vh vi vj vk vl vm vn vo vp vq vr vs vt vu vv vw vx vy vz) ,e1 ,e2))

(define-macro (waz e1 e2) (cw multiple-value-bind (wa wb wc wd we wf wg wh wi wj wk wl wm wn wo wp wq wr ws wt wu wv ww wx wy wz) ,e1 ,e2))

(define-macro (xaz e1 e2) (cw multiple-value-bind (xa xb xc xd xe xf xg xh xi xj xk xl xm xn xo xp xq xr xs xt xu xv xw xx xy xz) ,e1 ,e2))

(define-macro (yaz e1 e2) (cw multiple-value-bind (ya yb yc yd ye yf yg yh yi yj yk yl ym yn yo yp yq yr ys yt yu yv yw yx yy yz) ,e1 ,e2))

(define-macro (zaz e1 e2) (cw multiple-value-bind (za zb zc zd ze zf zg zh zi zj zk zl zm zn zo zp zq zr zs zt zu zv zw zx zy zz) ,e1 ,e2))

(define-macro (va ex) (cw v (vaz (av (cons v vv)) ,ex)))

(define-macro (wa ex) (cw w (waz (av (cons w ww)) ,ex)))

(define-macro (xa ex) (cw x (xaz (av (cons x xx)) ,ex)))

(define-macro (ya ex) (cw y (yaz (av (cons y yy)) ,ex)))

(define-macro (za ex) (cw z (zaz (av (cons z zz)) ,ex)))

(define-macro (v ex) (cw lambda (v &rest vv) ,ex))

(define-macro (w ex) (cw lambda (w &rest ww) ,ex))

(define-macro (x ex) (cw lambda (x &rest xx) ,ex))

(define-macro (y ex) (cw lambda (y &rest yy) ,ex))

(define-macro (z ex) (cw lambda (z &rest zz) ,ex))

(define fc (z (apply z zz)))

(define pred (za (mapped (y (if (fc za y) (or y #t))))))

(define less (z (tree-mapped (type (y (if (< y z) y)) number?))))

(define more (z (tree-mapped (type (y (if (> y z) y)) number?))))

(define y= (z (tree-mapped (type (y (if (= y z) (or y #t))) number?))))

(define == (z (mapped (y (if (eq? y z) (or y #t))))))

(define === (z (mapped (y (if (eqv? y z) (or y #t))))))

(define ==== (z (mapped (y (if (equal? y z) (or y #t))))))

(define n= (z (tree-mapped (type (y (if (not (= y z)) (or y #t))) number?))))

(define n== (z (mapped (y (if (not (eq? y z)) (or y #t))))))

(define n=== (z (mapped (y (if (not (eqv? y z)) (or y #t))))))

(define n==== (z (mapped (y (if (not (equal? y z)) (or y #t))))))

(define make-adder (z (tree-mapped (type (y (+ y z)) number?))))

(define predor (z (mapped (letrec ((rec (ya (if yb (or (apply (car yb) ya) (rec ya (cdr yb))) ())))) (x (let ((xs (cons x xx))) (or (apply z xs) (rec xs zz))))))))

(define predand (z (mapped (letrec ((rec (ya (if yb (and (apply (car yb) ya) (rec ya (cdr yb))) (or (car ya) #t))))) (x (let ((xs (cons x xx))) (if (apply z xs) (rec xs zz))))))))

(define predfn (z (mapped (y (let ((ys (cons y yy))) (if (apply (apply predand zz) ys) (apply z ys)))))))

(define fnfn (z (mapped (letrec ((rec (ya (if yb (rec ((car yb) ya) (cdr yb)) ya)))) (x (rec (apply z (cons x xx)) zz))))))

(define type (z (mapped (y (or ((predfn z (apply predand zz)) y) (if ((apply predand zz) y) () y))))))

(define mapped (z (y (if yy (map z (cons y yy)) (fc z y)))))

(define mapped (mapped mapped))

(define tree-mapped (z (letrec ((rec (y (if yy (map rec (cons y yy)) (if (pair? y) (map rec y) (fc z y)))))) (x (apply rec (cons x xx))))))

(define tree-mapped (mapped tree-mapped))

(define nthcdr (z (mapped (y (if (= 0 z) y ((nthcdr (- z 1)) (cdr y)))))))

(define subseq (za (mapped (y (letrec ((rec (xa (if (= 0 xb) (reverse xc) (rec (cdr xa) (- xb 1) (cons (car xa) xc)))))) (rec ((nthcdr za) y) (- zb za) ()))))))

(define findcar (z (mapped (y (if y (if (fc z (car y)) (values (car y) y) ((findcar z) (cdr y))))))))

(define append1 (za (append za (list zb))))

(define conc1 (za (append! za (list zb))))

(define longer (za (mapped (y (letrec ((rec (x (if (number? x) x (if (string? x) (string-length x) (if (vector? x) (vector-length x) (if (list? x) (length x) (error x))))))) (compare (wa (and (pair? wa) (or (not wb) (compare (cdr wa) (cdr wb))))))) (values (if (if (if (list? za) (list? y)) (compare y za) (> (rec y) (rec za))) y) za y))))))

(define longer-object (z (mapped (y (abc ((longer y) z) (if a c b))))))

(define shorter-object (z (mapped (y (abc ((longer z) y) (if a b c))))))

(define filter (z (mapped (y (letrec ((rec (xa (if xb (let ((val (fc xa (car xb)))) (if val (rec xa (cdr xb) (cons val xc)) (rec xa (cdr xb) xc))) (reverse xc))))) (rec z y ()))))))

(define group (z (mapped (y (letrec ((rec (xa (let ((rest ((nthcdr z) xa))) (if (pair? rest) (rec rest (cons ((subseq 0 z) xa) xb)) (reverse (cons xa xb))))))) (if (= 0 z) (error 0) (if y (rec y ()))))))))

(define prune (z (mapped (y (letrec ((rec (xa (if xa (if (pair? (car xa)) (rec (cdr xa) (cons (rec (car xa) ()) xb)) (rec (cdr xa) (if (fc z (car xa)) xb (cons (car xa) xb)))) (reverse xb))))) (rec y ()))))))

(define find#t (z (mapped (y (if y (let ((val (fc z (car y)))) (if val (values (car y) val) ((find#t z) (cdr y)))) y)))))

(define (before x y lst &key (test ==)) (if lst (let ((first (car lst))) (if ((test y) first) () (if ((test x) first) lst (before x y (cdr lst) :test test))))))

(define (after x y lst &key (test ==)) (let ((rest (before y x lst :test test))) (and rest (multiple-value-bind (a b) ((findcar (test x)) rest) b))))

(define (duplicate obj lst &key (test ==)) (multiple-value-bind (a b) ((findcar (test obj)) (cdr (multiple-value-bind (a b) ((findcar (test obj)) lst) b))) b))

(define split-at (z (mapped (y (letrec ((rec (xa (if xa (if (fc z (car xa)) (values (reverse xb) xa) (rec (cdr xa) (cons (car xa) xb))) (values (reverse xb) xa))))) (rec y ()))))))

(define 2x (z (* 2 z)))

(define 2x (type 2x number?))

(define 2x (tree-mapped 2x))

(define last1 (z (car (last-pair z))))

(define last1 (mapped last1))

(define single (z (and (pair? z) (not (cdr z)) z)))

(define single (mapped single))

(define mklist (z (if (list? z) z (list z))))

(define mklist (mapped mklist))

(define flatten (z (letrec ((rec (ya (if ya (if (atom? ya) (cons ya yb) (rec (car ya) (rec (cdr ya) yb))) yb)))) (rec z ()))))

(define flatten (mapped flatten))

(define (sy &rest zs) (if zs ((fnfn (tree-mapped (y (if (char? y) y (if (integer? y) (integer->char y) (if (string? y) (string->list y) ((fnfn symbol->string string->list) y)))))) flatten list->string string-upcase intern) zs) (gensym)))

(define (spy &rest zs) (if zs ((fnfn (group 1) (y (map (x (append1 x #\space)) y)) (tree-mapped (w (if (char? w) w (if (integer? w) (string->list (number->string w)) (if (string? w) (string->list w) ((fnfn symbol->string string->list) w)))))) flatten list->string string-upcase intern) zs) (gensym)))

(define ch (z (char->integer z)))

(define ch (mapped ch))

(define mp (za (mapped (y (apply append (map (x (apply x za)) (map mapped (cons y yy))))))))

(define tp (za (mapped (y (apply append (map (x (apply x za)) (map tree-mapped (cons y yy))))))))

(define ma (z (y (apply map (cons z (cons y yy))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;; BASE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(newline)

(elist '(f o u r))

(newline)

(display "H u t c h i n s o n")

(prn (abc (+ 1 2) a)
3
)

(prn (abc (+ 1 2) t)
()
)

(MARK prn (abc (values h a z e l) (list c d e b a))
(
z e l a h
))

(prn ((y (list y yy)) 1 2 3 4 5 6 7)
(
1 (2 3 4 5 6 7)
))

(prn ((z (list z zz)) 1 2 3 4 5 6 7)
(
1 (2 3 4 5 6 7)
))

(prn ((za (+ za zd zg)) 1 2 3 4 5 6 7)
12
)

(prn ((ya (+ ya yd yg)) 1 2 3 4 5 6 7)
12
)

(prn (cw define c ,(+ 1 0))
(
define c 1
))

(prn (cw define d (+ 1 c))
(
define d (+ 1 c)
))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;; STRESS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(prn 42
42
)

(prn (+ 21 21)
42
)

(prn (list f o o t)
(
f o o t
))

(prn (list z e l a h)
(
z e l a h
))

(prn (fc + 1 2 3)
6
)

(prn (fc map - '(1 2 3))
(
-1 -2 -3
))

(prn (fc fc fc + 1 2 3)
6
)

(prn ((pred odd?) 1 2)
(
1 ()
))

(prn ((pred odd?) 2)
()
)

(prn ((pred (pred odd?)) 1)
1
)

(prn ((more 3) 4)
4
)

(prn ((more 3) 3)
()
)

(prn ((more 0) -3 -2 '(-1 0 1 2) () 3)
(
() () (() () 1 2) () 3
))

(prn ((more 0) '(-3 -2 (-1 0 1 2) () 3))
(
() () (() () 1 2) () 3
))

(prn ((less 3) 4)
()
)

(prn ((less 3) 2)
2
)

(prn ((less 0) -3 -2 '(-1 0 1 2) () 3)
(
-3 -2 (-1 () () ()) () ()
))

(prn ((less 0) '(-3 -2 (-1 0 1 2) () 3))
(
-3 -2 (-1 () () ()) () ()
))

(prn ((y= 0) 0)
0
)

(prn ((y= 0) 1)
()
)

(prn ((y= 0) 0 '(1) 0 '(1) '(1) 0 '(1) 0)
(
0 (()) 0 (()) (()) 0 (()) 0
))

(prn ((y= 0) '(0 (1) 0 (1) (1) 0 (1) 0))
(
0 (()) 0 (()) (()) 0 (()) 0
))

(prn ((== "123") "123")
()
)

(prn ((=== "123") "123")
"123"
)

(prn ((==== "123") "124" "123")
(
() "123"
))

(prn ((== ()) ())
#t
)

(prn ((=== ()) ())
#t
)

(prn ((==== ()) ())
#t
)

(prn ((n== 0) ())
#t
)

(prn ((n=== 0) ())
#t
)

(prn ((n==== 0) ())
#t
)

(prn ((make-adder -1) 43)
42
)

(prn ((make-adder -1) '((1 2 (3) 4 ((5))) 6))
(
(0 1 (2) 3 ((4)))
5
))

(prn ((make-adder -1) '(((1 2 (3) 4 ((5))) 6)))
(
((0 1 (2) 3 ((4))) 5)
))

(prn ((predor number? null?) 3 "3" ())
(
#t () #t
))

(prn ((predand (more 0) (less 43)) 42 43 1)
(
42 () 1
))

(prn ((predfn - number? odd?) 3)
-3
)

(prn ((predfn - number? odd?) 4)
()
)

(prn ((predfn not null?) ())
#t
)

(prn ((predfn not null?) 3 4 5)
(
() () ()
))

(prn ((fnfn 2x -) 3)
-6
)

(prn ((type - number?) 3)
-3
)

(prn ((type - number?) "three")
"three"
)

(prn ((mapped -) 1 2 3)
(
-1 -2 -3
))

(prn ((tree-mapped -) 1 2 3)
(
-1 -2 -3
))

(prn ((tree-mapped -) '(1 ((2)) 3))
(
-1 ((-2)) -3
))

(prn ((nthcdr 0) '(1 2 3))
(
1 2 3
))

(prn ((nthcdr 2) '(1 2 3) '(4 5 6))
(
(3) (6)
))

(prn ((subseq 1 3) '(1 2 3))
(
2 3
))

(prn ((subseq 1 3) '(1 2 3) '(4 5 6 7 8 9))
(
(2 3) (5 6)
))

(prn (abc ((findcar odd?) '(2 3 4 5)) (list a b))
(
3 (3 4 5)
))

(prn ((findcar odd?) '(2 3 4 5 7) '(5 4 3 2))
(
3 5
))

(prn (append1 '(1 2 3) 4)
(
1 2 3 4
))

(prn (conc1 '(1 2 3) 4)
(
1 2 3 4
))

(prn (abc ((longer '(1 2 3 4)) '(1 2)) (if a c b))
(1 2 3 4)
)

(prn ((longer '(1 2 3)) "007" '(good job) 2 5 '(very very good job))
(
() () () 5 (very very good job)
))

(prn ((longer-object '(1 2 3)) "007" '(good job) 2 5 '(very very good job))
(
"007" (1 2 3) (1 2 3) 5 (very very good job)
))

(prn ((shorter-object '(1 2 3)) "007" '(good job) 2 5 '(very very good job))
(
"007" (good job) 2 (1 2 3) (1 2 3)
))

(prn ((filter (predfn - number? odd?)) '(1 2 3 4 5 6 7 8 9))
(
-1  -3  -5  -7  -9
))

(prn ((filter (predfn - number? odd?)) '(1 2 3) '(4 5 6))
(
(-1  -3) (-5)
))

(prn ((group 4) '(has every value quantum computer zelah) )
(
(has every value quantum) (computer zelah)
))

(prn ((group 2) '(a reusable program izza good program) '(what good does zelah mind unleash ?))
(
((a reusable) (program izza) (good program)) ((what good) (does zelah) (mind unleash) (?))
))

(prn ((prune (more 3)) '((1 2 (3) ((4))) 5 6 (7)))
(
(1 2 (3) (())) ()
))

(prn ((prune (more 3)) '(1 2 (3) 4) '(3 5 6 (7)))
(
(1 2 (3)) (3 ())
))

(prn (abc ((find#t odd?) '(2 3 4 5)) (list a b))
(
3 #t
))

(prn ((find#t odd?) '(1) '(2 3 4 5))
(
1 3
))

(prn (before 1 3 '(1 2 3))
(
1 2 3
))

(prn (after 1 3 '(1 2 3))
()
)

(prn (duplicate 'good '(good enough is good enough))
(
good enough
))

(prn (abc ((split-at (== 'quantum)) '(has every value quantum computer zelah)) (list a b))
(
(has every value) (quantum computer zelah)
))

(prn ((split-at (more 3)) '(1 2 3 4 5 6 7) '(7 6 5 4 3 2 1))
(
(1 2 3) ()
))

(prn (2x 2)
4
)

(prn (2x 1 2 3)
(
2 4 6
))

(prn (2x '(((1 (2) 3))))
(
((2 (4) 6))
))

(prn (last1 '(1 2 3))
3
)

(prn (last1 '(3 2 1) '(1) '(7 6 5 4 3 2 1))
(
1 1 1
))

(prn (single '(one two))
()
)

(prn (single '(solo))
(
solo
))

(prn (single '(3 2 1) '(1) '(2 1))
(
() (1) ()
))

(prn (mklist 'solo)
(
solo
))

(prn (mklist '(solo))
(
solo
))

(prn (mklist '(solo) 'solo '(solo))
(
(solo) (solo) (solo)
))

(prn (flatten '(((()(buried)((()treasure()))))))
(
buried treasure
))

(prn (flatten '(()()) '((())) () '(()()()))
(
() () () ()
))

(prn (sy s y)
sy
)

(prn (sy a #\b "c" (ch #\+) '(((k i s s + (m (e))))))
abc+kiss+me
)

(prn (ch #\Z #\Z #\Z)
(
90 90 90
))

(prn ((mp '(2 4 6)) - (z (* z z)) (z (* z z z)))
(
(-2 -4 -6)
(4 16 36)
(8 64 216)
))

(prn ((tp '((2) 4 ((6)))) - (z (* z z)) (z (* z z z)))
(
((-2) -4 ((-6)))
((4) 16 ((36)))
((8) 64 ((216)))
))

(prn ((ma -) '(1 2))
(
-1 -2
))

(prn ((ma -) '(1 2 3) '(4 5 6))
(
-3 -3 -3
))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;; DEMO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

'(prnt (sy))

'(prnt (sy "(define" sp x sp "4)"))

'(prnt (spy "(" 'define x "4" ")"))

(prn ((mp '(((2)) ((1 2) (2 3)))) 2x (z (apply (ma -) z)))
(
(((4)) ((2 4) (4 6)))
(
(-2)
(-1 -1)
)
))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;; WASTES ;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define-macro (four . p)  (cw eval (read (make-string-input-stream (string-append "(for-each eval (quote (" (col (quote ,p)) ")))")))))

(define col (z (letrec ((com (type (y (list 'com (+ (round (* 100 (- (* 10 y) (truncate (* 10 y))))) (truncate (* 10 y))))) number? (less 1) (more 0))) (col (xa (if xa (if (and (list? xc) (list? (cdr xc)) ((== 'com) (car xc))) (col (cdr xa) (cons (apply spy (cons #\( (append1 (reverse ((subseq 0 (cadr xc)) xb)) #\)))) ((nthcdr (cadr xc)) xb)) (car xa)) (col (cdr xa) (cons xc xb) (car xa))) (string-downcase (symbol->string (apply spy (reverse xb)))))))) (col (apply com (append1 (cdr z) 0)) () (car z)))))

(prnt (sy (col (cw
;;;;;;;;;;
defn dub ([x]) * 2 x .3 .4
println dub ,(sy 34 "21" 34) .2 .2
;;;;;;;;;;
))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(newline)(newline)