stdlibForScheme

(define fact
  (lambda (n)
    (fact_h n 1)))

(define fact_h
  (lambda (n m)
    (if (<= n 0)
    m
    (fact_h (- n 1) (* m n)))))

(define fold
  (lambda xs
    (if (= (length xs) 2)
    (fold_h (car xs) (car (car (cdr xs))) (cdr (car (cdr xs))))
    (apply fold_h xs))))
(define fold_h
  (lambda (f x xs)
    (if (= (length xs) 0)
    x
    (fold_h f (f x (car xs)) (cdr xs)))))
(define range
  (lambda (n m)
    (if (<= n m)
    (range_h n (- m 1) '())
    (reverse (range_h (+ m 1) n '())))))

(define range_h
  (lambda (n m xs)
    (if (= n m)
    (cons m xs)
    (range_h n (- m 1) (cons m xs)))))

(define map-reduce
  (lambda (f b xs)
    (fold b (map f xs))))

(define map-fold map-reduce)
(define reduce fold)

(define fib_h
  (lambda (a b n)
    (if (<= n 1)
    b
    (fib_h b (+ a b) (- n 1)))))

(define fib
  (lambda (n)
    (fib_h 0 1 n)))

(define ntos
  (lambda args
    (cond
     ((= (length args) 1)
      (string-append (number->string (car args)) " "))
     ((= (length args) 2)
      (string-append (number->string (car args)) (car (cdr args)))))))

(define Y
  (lambda (f)
    ((lambda (x) (x x))
     (lambda (g)
       (f (lambda args (apply (g g) args)))))))

(define s-app-gen (lambda (n) (lambda (x v) (string-append x n v))))

(define != (lambda (a b) (not (= a b))))

(define readline
  (lambda ()
    (readline_h "") ))

(define readline_h
  (lambda(n)
    (let ((ch (read-char)))
      (cond
       ((eof-object? ch) n)
       (#t
    (let ((c (string ch)))
      (cond
       (
        (or (string=? c "\n") (string=? c "\r"))
        n
        )
       (#t
        (readline_h (string-append n c))))))))))

(define join
  (lambda (f xs ch)
    (map-reduce f (s-app-gen ch) xs)))

(define contains?
  (lambda (x xs)
    (if (null? xs)
    #f
    (if (eq? x (car xs))
        #t
        (contains? x (cdr xs))))))

(define in? contains?)

(define uniqueify
  (lambda (xso)
    (let loop ((ys '()) (xs xso))
      (if (null? xs)
      ys
      (if (contains? (car xs) ys)
          (loop ys (cdr xs))
          (loop (cons (car xs) ys) (cdr xs)))))))

(define (isqrt n)
  (if (= n 1)
      1
      (let ((xn (isqrt (- n 1))))
    (quotient (+ xn (quotient n xn)) 2))))

(define factors
  (lambda (nn)
    (let ((n (+ 1 (isqrt nn))))
      (let loop ((xs '()) (m 1))
    (if (>= m n)
        (uniqueify xs)
        (if (= (modulo nn m) 0)
        (loop (cons (quotient nn m) (cons m xs)) (+ m 1))
        (loop xs (+ m 1))))))))
(define repeat
  (lambda (n m)
    (let loop ((x m) (xs '()))
      (if (= x 0)
      xs
      (loop (- x 1) (cons n xs))))))