(define rl
  (lambda () (load "2.ss")))

(define make-range
  (lambda (lower upper)
    (cond [(>= lower upper) '()]
	  [else (cons lower (make-range (+ lower 1) upper))])))

(define curry2
  (lambda (f)
    (lambda (arg1)
      (lambda (arg2)
	(f arg1 arg2)))))

(define curried-compose
  (lambda (f)
    (lambda (g)
      (lambda (x)
	(f (g x))))))

(define compose
  (lambda l
    (cond [(= (length l) 2) (lambda (x) ((car l) ((cadr l) x)))]
	  [(= (length l) 3) (lambda (x) ((car l) ((cadr l) ((caddr l) x))))]
	  [else #f])))


(define largest2
  (lambda (l)
    (cond [(null? l) #f]
	  [(list? (car l)) (let [(temp1 (largest2 (car l)))
				 (temp2 (largest2 (cdr l)))]
			     (if (> temp1 temp2)
				 temp1
				 temp2))]
	  [else (if (null? (cdr l))
		    (car l)
		    (let [(temp (largest2 (cdr l)))]
		      (if (> temp (car l))
			  temp
			  (car l))))])))
(define largest largest2)
  
;(define largest
;  (lambda (l)
;    (largest-top-level-list (flatten l '()))))


(define largest-top-level-list
  (lambda (l)
    (cond [(null? l) #f]
	  [else (largest-helper (car l) (cdr l))])))

(define largest-helper
  (lambda (e l)
    (cond [(null? l) e]
	  [(> (car l) e) (largest-helper (car l) (cdr l))]
	  [else (largest-helper e (cdr l))])))
	   

;(define flatten
;  (lambda (l)
;    (cond [(null? l) '()]
;	  [(list? (car l)) (append (flatten (car l)) (flatten (cdr l)))]
;	  [else (cons (car l) (flatten (cdr l)))])))


(define flatten
  (lambda (l accu)
    (cond [(null? l) accu]
	  [(atom? (car l)) (cons (car l) (flatten (cdr l) accu))]
	  [else (flatten (car l) (flatten (cdr l) accu))])))


(define (set? l)
  (if (null? l)
      #t
      (if (member (car l) (cdr l))
	  #f
	  (set? (cdr l)))))


(define (intersection l1 l2)
  (cond [(null? l1) ()]
	[(null? l2) ()]
	[(member (car l1) l2) (cons (car l1) (intersection (cdr l1 l2)))]
	[else (intersection (cdr l1) l2)]))


(define (interval-union list1 list2)
  (if (> (car list1) (car list2))
      (interval-union list2 list1)
      (if (>= (cadr list1) (car list2))
	  (if (> (cadr list1) (cadr list2))
	      (list list1)
	      (list (cons (car list1) (cdr list2))))
	  (list list1 list2))))

(define relation?
  (lambda (l)
    (cond [(null? l) #t]
	  [(not (list? l)) #f]
	  [(not (list? (car l))) #f]
	  [(member (car l) (cdr l)) #f]
	  [(> (length (car l)) 2) #f]
	  [(< (length (car l)) 2) #f]
	  [(and (atom? (caar l)) (atom? (cadar l)))
	   (relation? (cdr l))]
	  [else #f])))


(define subset?
  (lambda (s1 s2)
    (cond [(null? s1) #t]
	  [(member (car s1) s2) (subset? (cdr s1) s2)]
	  [else #f])))