(define (m_map f l)
  (if (null? l) l
      (cons (f (car l)) (m_map f (cdr l)))
  )
)


(define (m_filter l f)
  (if (null? l) l
      (if (f (car l)) (cons (car l) (m_filter (cdr l) f))
          (m_filter (cdr l) f)))
)


(define (m_accumulate l f start)
  (if (null? l) start
      (m_accumulate (cdr l) f (f start (car l)))
  )
)


(define (m_min l)
  (m_accumulate l (lambda (a b) (if (< a b) a b )) (car l))
)


(define (remove-first l x)
  (if (null? l) l
      (if (= (car l) x) (cdr l)
          (cons (car l) (remove-first (cdr l) x))
      )
  )
)

(define (remove-first-fil l x)
  (m_filter l
            (lambda (a) ((let-rec ((query (and query (= x a)))) (not query))))
  )
)



(define (remove-min l)
  (remove-first-fil l (m_min l))
)



(define (sel-sort l)
  (if (null? l) l
      (cons (m_min l) (sel-sort (remove-min l)))
  )
)


;;;;;;;;;;;;;;;;;;;;;;;;
(define (m_reverse l)
  (m_accumulate l (lambda (a b) (cons b a)) '())
)

(define (m_append l1 l2)
  (m_accumulate (m_reverse l1) (lambda (a b) (cons b a)) l2)
)

(define (first-n l n)
  (if (= n 0) '()
      (cons (car l) (first-n (cdr l) (- n 1)))
  )
)

(define (last-n l n)
  (reverse (first-n (reverse l) n))
)

(define (q-sort l)
  (if (null? l) '()
      (append (q-sort (m_filter (cdr l) (lambda (x) (< x (car l)))))
              (cons (car l) '())
              (q-sort (m_filter (cdr l) (lambda (x) (not (< x (car l))))))
      )
  )
)

(define (merge m1 m2)
  (cond ((null? m1) m2)
        ((null? m2) m1)
        ((< (car m1) (car m2)) (cons (car m1) (merge (cdr m1) m2)))
        (else (cons (car m2) (merge (cdr m2) m1)))
  )
)

(define (merge-sort l)
  (let* ((len (length l))
         (len-2 (quotient len 2))
         (len-res (- len len-2))
        )
    (if (null? l) '()
        (if (null? (cdr l)) l
            (merge (merge-sort (first-n l len-2)) (merge-sort (last-n l len-res)))
        )
    )
  )
)

(define (flatten l)
  l
)