anchor.diff:  ;;; psr-variaveis-nao-atribuidas: PSR -> lista de variaveis
   (defun psr-variaveis-nao-atribuidas (p)
     "Devolve lista de variaveis nao atribuidas (pela ordem inicial)."
  - (mapcan #'(lambda (v) (when (not(= (length (gethash v (psr-pares p))) 1)) (list v))) 
  + (mapcan #'(lambda (v) (when (not(= (length (elt (gethash v (psr-pares p)) 0)) 1)) (list v))) 
   	      (psr-variaveis-todas p)))
   
   
   ;;; psr-variavel-valor: PSR x variavel -> objecto
   (defun psr-variavel-valor (p v)
     "Devolve o valor atribuido a variavel (caso nao exista atribuicao devolve nil)."
  -  (first (gethash v (psr-pares p) nil))) ; nao testa se e' atribuicao!!
  -					 ; devolve apenas o primeiro elem do dominio
  +  (let ((d (psr-variavel-dominio p v)))
  +    (if (= 1 (length d)) (first d) nil)))
   
   
   ;;; psr-variavel-dominio: PSR x variavel -> dominio
   (defun psr-variavel-dominio (p v)
     "Devolve o dominio associado a uma variavel."
  -  (gethash v (psr-pares p)))
  +  (elt (gethash v (psr-pares p)) 0))
   
   
   ;;; psr-variavel-restricoes: PSR x variavel -> lista restricoes
   (defun psr-variavel-restricoes (p v)
     "Devolve uma lista com todas as restricoes aplicaveis a uma variavel."
  -  (remove-if-not #'(lambda (l) (member v l :test #'equal)) (psr-restricoes p) :key #'restricao-variaveis)
  -  
  -  ; (remove "a" (list r1 r2) :key #'restricao-variaveis :test-not #'(lambda(r l) (member r l :test #'equal)))
  -)
  +  (elt (gethash v (psr-pares p)) 1))
   
   
   (defun psr-restricoes-ambas-variaveis (p v1 v2)
  
positive.code: ;;; psr-adiciona-atribuicao!: PSR x variavel x valor -> {}
  (defun psr-adiciona-atribuicao! (p v n)
    ""
    (setf (gethash v (psr-pares p)) (list n)))
  
  
  ;;; psr-remove-atribuicao!: PSR x variavel -> {}
  (defun psr-remove-atribuicao! (p v)
    ""
    (setf (gethash v (psr-pares p)) nil))
  
  
  ;;; psr-altera-dominio!: PSR x variavel x dominio {}
  (defun psr-altera-dominio! (p v d)
    ""
    (setf (gethash v (psr-pares p)) d))
  
  
  ;;; psr-completo-p: PSR -> logico
  
negative.code: (defun cria-psr (variaveis dominios restricoes)
    ""
    (let ((pares (make-hash-table :test 'equal)))
      (mapcar #'(lambda (v d) (setf (gethash v pares) (vector d nil))) variaveis dominios)
      (dolist (r restricoes)
        (dolist (v (restricao-variaveis r) v)
  	(push r (elt (gethash v pares) 1))))
      (maphash #'(lambda (v dr) (declare (ignore v)) (nreverse (elt dr 1))) pares)
      (make-psr :variaveis-todas variaveis :pares pares :restricoes restricoes)))
  
  
  