anchor.diff:      (return-from psr-forward-checking (values inferencias testes-totais))))
   
   
  -;(defun psr-arcos-vizinhos-nao-atribuidos (p v)
  -;  ""
  -;  (let ((lista-arcos (list))) ; lista vs vector?
  -;    (dolist (v-na (psr-variaveis-nao-atribuidas p))
  -;      (when (not (equal v v-na))
  -;	(when (some #'(lambda (r) (find r (psr-variavel-restricoes p v-na)))
  -;		    (psr-variavel-restricoes p v))
  -;	  (push (cons v-na v) lista-arcos))))
  -;    (nreverse lista-arcos)))
  -
  -
   (defun psr-arcos-vizinhos-nao-atribuidos2 (p v)
     ""
     (let ((lista-arcos (list))
  -	(envolvidas (remove-duplicates (reduce #'append (psr-variavel-restricoes p v) ; TODO: rever
  +	(envolvidas (remove-duplicates (reduce #'append (psr-variavel-restricoes p v)
   					       :key 'restricao-variaveis)
   				       :test 'equal)))
  -;    (format t "A variavel ~a tem estas restricoes:~a~%" v (psr-variavel-restricoes p v))
  -;    (format t "PAVNA: v:~a~%restricoes:~a~%envolvidas:~a~%" v (psr-variavel-restricoes p v) envolvidas)
  -;    (format t "PAVNA: var-natribuidas:~a~%" (psr-variaveis-nao-atribuidas p))
       (dolist (v-na (psr-variaveis-nao-atribuidas p))
         (when (not (equal v v-na))
   	(when (find v-na envolvidas :test 'equal)
   	  (push (cons v-na v) lista-arcos))))
   
       (nreverse lista-arcos)))
  -
  -
  -;; (defun psr-revise (p x y inferencias)
  -;;   ""
  -;;   (let* ((testes-total 0)
  -;; 	 (revised nil)
  -;; 	 (dominio-x (gethash x inferencias (psr-variavel-dominio p x)))
  -;; 	 (novo-dominio-x dominio-x)
  -;; 	 (dominio-y (if (psr-variavel-atribuida-p p y)
  -;; 			(psr-variavel-dominio p y)
  -;; 			(gethash y inferencias (psr-variavel-dominio p y)))))
  -
  -;;     (dolist (valor-x dominio-x)
  -;;       (when (dolist (valor-y dominio-y t)
  -;; 	      (multiple-value-bind (consistente testes)
  -;; 		  (psr-atribuicoes-consistentes-arco-p p x valor-x y valor-y)
  -;; 		(incf testes-total testes)
  -;; 		(when consistente (return nil))))
  -;; 	(setf revised t)
  -;; 	(setf novo-dominio-x (remove valor-x novo-dominio-x))))
  -
  -;;     (when revised
  -;;       (setf (gethash x inferencias) novo-dominio-x)) ; TODO: sobrepor?
  -
  -;;     (values revised testes-total)))
   
   
   (defun psr-revise2 (p x y inferencias)
  
positive.code: 	(let* ((v (psr-var-maior-grau p))
  	       (d (psr-variavel-dominio p v)))
  
  ;	  (when DEBUG (format t "Escolhi a variavel:~a cujo dominio e:~a~%" v (psr-variavel-dominio p v)))
  	  (dolist (valor d)
  	    (multiple-value-bind (consistente testes) (psr-atribuicao-consistente-p p v valor)
  	      (incf testes-total testes)
  ;	      (when DEBUG (format t "Fiz ~a testes de consistencia. O total vai em:~a~%" testes testes-total))
  	      (when consistente
  ;		(when DEBUG (format t "Atribuindo o valor:~a a variavel:~a~%" valor v))
  		(psr-adiciona-atribuicao! p v valor)
  
  ;		(when DEBUG
  ;		  (format DEBUG "Depois da atribuicao~%")
  ;		  (desenha-fill-a-pix (psr->fill-a-pix p LC LC)))
  
  		(multiple-value-bind (recurs-consistente recurs-testes) (procura-retrocesso-grau p)
  		  (incf testes-total recurs-testes)
  ;		  (when DEBUG
  ;		    (format t "Somando os ~a desta iteracao com os ~a que vem de tras fica:~a~%" testes recurs-testes testes-total))
  		  (when (not (null recurs-consistente))
  		    (return-from procura-retrocesso-grau (values p testes-total))))
  
  		(psr-remove-atribuicao! p v)
  ;		(when DEBUG
  ;		  (print "Removendo a atribuicao:")
  ;		  (desenha-fill-a-pix (psr->fill-a-pix p LC LC)))
  		)))
  	  (return-from procura-retrocesso-grau (values nil testes-total))))))
  
  
  
negative.code: 
  		  (maphash #'(lambda (bv bd)
  			       (psr-altera-dominio! p bv bd))
  			   backup)))
  
  	      (psr-remove-atribuicao! p v))))))
  
      (return-from procura-retrocesso-mac-mrv (values nil testes-totais))))
  
  