The procedure +, * and list take arbitrary numbers of arguments. One way to define such a procedure is to use define with dotted-tail notation. In a procedure definition, a parameter list that has a dot before the last parameter name indicates that, when the procedure is called, the initial parameters (if any) will have as values the initial arguments, as usual, but the final parameter's value will be a list of any remaining arguments. For instance, give the definition:

(define (f x y . z) )

the procedure f can be called with two or more arguments. If we evaluate

(f 1 2 3 4 5 6)

then in the body of f, x will be 1, y will be 2, and z will be the list (3 4 5 6).

Given the definition:

(define (g . w) )

the procedure g can be called with 0 or more arguments. If we evaluate

(g 1 2 3 4 5 6)

then in the body of g, w will be the list ( 1 2 3 4 5 6).

(a) Use this notation to write a procedure average that takes one or more integers and returns the average. For example:

(average 1 2 3 4 5 6 7) => 4
(average 2) => 2

(b) Write a procedure called pipeline that accepts a variable number of arguments that are procedures and returns the composition of those procedures. This is called pipeline processing. You may assume that all procedures in the pipeline accept a single argument. For example:
(define square-cubed (pipeline square square square))
; is equivalent to:
(define square-cubed (lambda (x) (square (square (square x)))))
(square-cubed 2) => 256

(c) Using your definition for pipeline from (b), write procedures for cdar, cddar and cdadr.