(define f0 
  (lambda (x) 
    (+ x 1)))

(define fntimes 
  (lambda (f n x) 
    (if (> n 0) 
        (fntimes f (- n 1) (f x)) 
        (begin 
          (display "\t")
          (display x)
          (display "\n")
          x))))

(define nthf 
  (lambda (basef n) 
    (let ((nth (lambda (x) 
                 (if (> n 0) 
                     (fntimes (nthf basef (- n 1)) x x) 
                     (basef x))))) 
      nth)))

(define g 
  (lambda (x) 
    (fntimes (nthf f0 x) x x)))

(define ncat (lambda (n x)
               (if (> n 0)
                   (cons x (ncat (- n 1) x))
                   '())))

(define reduce-list (lambda (lst carry)
                      (if (null? lst)
                          '()
                          (let ((c (fntimes (nthf f0 carry) (g carry) (car lst))))
                            (cons c (reduce-list (cdr lst) c))))))

(define h
  (lambda (x)
    (if (list? x)
        (if (null? x)
            1
            (if (null? (cdr x))
                (g (car x))
                (h (reduce-list (cdr x) (car x)))))
        0)))

(define i
  (lambda (x)
    (h (ncat x x))))

; Easy way to print off g(0..n) for a given function g(x)
(define rep
  (lambda (g max)
    (let ((print (lambda (x)
                   (begin
                     (display x)
                     (display "\n")))))
      (letrec ((iter (lambda (curr)
                    (if (< curr max)
                        (begin
                          (print (g curr))
                          (iter (+ 1 curr)))
                        (print (g curr))))))
        (iter 0)))))