1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56

!(def typ (lambda (x) (car (cdr x))))

!(def funtl (lambda (x) (car (cdr (typ x)))))

!(def funtr (lambda (x) (car (cdr (cdr (typ x))))))

!(def funv (lambda (x) (car (cdr (cdr x)))))

!(def funb (lambda (x) (car (cdr (cdr (cdr x))))))

!(def check (lambda (x)
  (if (eq (car x) "fun")
      (if (eq (car (typ x)) "fun")
          (if (eq (car ()))


               let ((car (cdr (cdr x))) (car (cdr (car (cdr x)))))
               (check ))
      nil


      )
    

  ) (if (eq (car x) "app") (
                        )

    (if (eq (car x) "prod")) (
    )
    (if (eq (car x) "sum")) ())
    nil))))



(check
  (list "fun" (list "fun" "A" (list "fun" "B" (list "prod" "B" "A"))) "a"
    (list "fun" (list "fun" "B" (cons "B" "A")) "b"
      (list "prod" (list "list" "B" "A") "b" "a"))))

123

(+ 1 1)

!(def square (lambda (x) (* x x)))

(square 8)

!(def make-adder
   (lambda (n)
     (lambda (x)
       (+ x n))))

!(def five-plus
   (make-adder 5))

(five-plus 3)