#| BEGIN (Введите свое решение) |#
(define (deriv exp var)
  (cond ((number? exp) 0)
        ((variable? exp)
         (if (same-variable? exp var) 1 0))
        ((sum? exp)
         (make-sum (deriv (addend exp) var)
                   (deriv (augend exp) var)))
        ((product? exp)
         (make-sum
           (make-product (multiplier exp)
                         (deriv (multiplicand exp) var))
           (make-product (deriv (multiplier exp) var)
                         (multiplicand exp))))
        ((exponentiation? exp)
         (make-product
           (make-product (exponent exp)
                         (make-exponentiation (base exp)
                                              (make-sum (exponent exp) -1)))
           (deriv (base exp) var)))
        (else
          (error "unknown type of expression -- DERIV" exp))))

(define (variable? x) (symbol? x))

(define (same-variable? v1 v2)
  (and (variable? v1) (variable? v2) (eq? v1 v2)))

(define (sum? x)
  (and (pair? x) (pair? (cdr x)) (eq? (cadr x) '+)))

(define (addend s)
  (if (pair? s) (car s) s))

(define (augend s)
  (if (and (pair? s) (pair? (cddr s)))
      (caddr s)
      s))

(define (product? x)
  (and (pair? x) (pair? (cdr x)) (eq? (cadr x) '*)))

(define (multiplier p)
  (if (pair? p) (car p) p))

(define (multiplicand p)
  (if (and (pair? p) (pair? (cddr p)))
      (caddr p)
      p))

(define (exponentiation? x)
  (and (pair? x) (pair? (cdr x)) (eq? (cadr x) '**)))

(define (make-sum a1 a2)
  (cond ((eq-number? a1 0) a2)
        ((eq-number? a2 0) a1)
        ((and (number? a1) (number? a2)) (+ a1 a2))
        (else (list '+ a1 a2))))

(define (make-product m1 m2)
  (cond ((or (eq-number? m1 0) (eq-number? m2 0)) 0)
        ((eq-number? m1 1) m2)
        ((eq-number? m2 1) m1)
        ((and (number? m1) (number? m2)) (* m1 m2))
        (else (list '* m1 m2))))

(define (make-exponentiation b e)
  (cond ((eq-number? e 0) 1)
        ((eq-number? e 1) b)
        ((eq-number? b 1) 1)
        ((and (number? e) (number? b)) (expt b e))
        (else (list '** b e))))

(define (eq-number? exp num)
  (and (number? exp) (= exp num)))

(define (base b)
  (if (pair? b) (car b) b))

(define (exponent e)
  (if (and (pair? e) (pair? (cddr e)))
      (caddr e)
      e))
#| END |#