(define (where-can-i-go? wd board_size)
	(let* ((x (car wd)) (y (cadr wd))
		(u1 (- y 1)) (u2 (- y 2)) (d1 (+ y 1)) (d2 (+ y 2))
		(l1 (- x 1)) (l2 (- x 2)) (r1 (+ x 1)) (r2 (+ x 2))
		(valid (lambda (x y)
				 (if (and (> x 0) (> y 0) (<= x board_size) (<= y board_size)) (list (se x y)) '()))))
	(append (valid l1 u2) (valid r1 u2)
		(valid l2 u1) (valid r2 u1)
		(list wd)	
		(valid l2 d1) (valid r2 d1)
		(valid l1 d2) (valid r1 d2))
	))

(define (create-board visited board_size)
	(let ((limit (- (* board_size board_size) 1)))
	     (define (value i j)
		     (let ((this (se i j)))
			  (se (count (keep (lambda (x) (not (member x visited))) (where-can-i-go? this board_size))) this)
		     ))
	     (define (my-loop l)
		     (let* ((i (+ (remainder l board_size) 1)) (j (+ (quotient l board_size) 1))
			    (temp (value i j)))
		     	   (if (= l limit)
	 		       (insert temp '())
			       (insert temp (my-loop (+ l 1)))
			   )))
	(my-loop 0)
	)) 		  

(define (insert elem lst)
	(let ((this (car elem)))
	     (define (helper lst)
		     (if (null? lst)
		         (list elem)
		         (if (< (caar lst) this)
			     (cons elem lst)
			     (cons (car lst) (helper (cdr lst)))
			 )))
	     (if (= (car elem) 0)
	         lst
	         (helper lst)
	     )))

(define (fill-board visited board_size n_knights)
	(let ((newlist (create-board visited board_size)))
	     (if (null? newlist)
		 #t
		 (if (or (< (* n_knights 9) (- (* board_size board_size) (count visited))) (= n_knights 0))
		     #f
		     (there-exists? newlist
			            (lambda (x)
					    (let* ((this (cdr x))
						  (rest (fill-board (append visited (where-can-i-go? this board_size)) board_size (- n_knights 1))))
						 (if rest (cons this rest) #f))))))))

(define words '(a b c d e f g h i))

(define (convert lst)
	(if (pair? lst)
	    (let ((this (car lst)))
	         (se (word (item (car this) words) (cadr this)) (convert (cdr lst)))
            )
	    '()
        ))
 
(define (cover board_size n_knights)
        (let ((solution (fill-board '() board_size n_knights)))
	     (if solution (convert solution) '())
	))