anchor.diff:    (target-transpile-generic tr
   	  :files-before-deps files-before-deps
   	  :files-after-deps files-after-deps
  -	  :front-before #'(()
  -  			            (target-transpile-1 tr files-before-deps))
  -	  :front-after #'(()
  -		 	           (target-transpile-1 tr files-after-deps))
  -	  :back-after #'((processed)
  -			          (target-transpile-2 tr processed))
  -	  :back-before #'((processed)
  -	  		           (target-transpile-2 tr processed))
  +	  :front-before
  +  		  #'(()
  +  			   (target-transpile-1 tr files-before-deps))
  +	  :front-after
  +  		  #'(()
  +		 	   (target-transpile-1 tr files-after-deps))
  +	  :back-after
  +  		  #'((processed)
  +			   (target-transpile-2 tr processed))
  +	  :back-before
  +  		  #'((processed)
  +	  		   (target-transpile-2 tr processed))
   	  :dep-gen dep-gen
   	  :decl-gen decl-gen
         :print-obfuscations? print-obfuscations?))
  
positive.code: 								   		 (dep-gen nil)
  							 	   		 (decl-gen nil)
                                           (print-obfuscations? nil))
    (with (before-deps (funcall front-before)
  		 after-deps (funcall front-after))
  	(format t "; Importing dependencies...~%")
  	(awhen dep-gen
        (acons! 'text (funcall !) after-deps))
      (format t "; Let me think. Hmm...~%")
  	(with (compiled-before (funcall back-before before-deps)
  		   compiled-after (funcall back-after after-deps))
  	  (prog1
  	    (concat-stringtree (awhen decl-gen
  		                     (funcall !))
  			               compiled-before
                             (reverse (transpiler-raw-decls tr))
  			               compiled-after)
          (when print-obfuscations?
            (transpiler-print-obfuscations tr))))))
  
  (defun target-transpile-0 (tr &key (files-after-deps nil)
  							  	   (files-before-deps nil)
  
negative.code: (defun target-transpile-recompile-2 (tr new old files-to-update)
    (mapcar #'((n o)
  			   (format t "Recompiling backend file ~A~%" n.)
  			   (concat-stringtree
  			       (if (recompile-file? n files-to-update)
  				       (transpiler-transpile tr .n)
  					   o)))
  		  new old))
  
  (defun target-transpile-2 (tr files)
    (mapcar (fn concat-stringtree (transpiler-transpile tr ._))
  		  files))
  
  (defun target-transpile-recompile-1 (tr compiled-files files-to-update)
    (let sightened-code nil
  	(dolist (i compiled-files sightened-code)
    	  (format t "Recompiling frontend file ~A~%" i.)
  	  (append! sightened-code
  			   (list (if (recompile-file? i files-to-update)
  						 (cons i.
  		  				       (transpiler-sighten-files tr (list i.)))
  		  				 i))))))
  
  (defun target-transpile-1 (tr files)
    (let sightened-code nil
  	(dolist (i files sightened-code)
  	  (append! sightened-code
  			   (list (cons i.
  	  				       (if (eq 'text i.)
  		  				       (transpiler-sighten tr .i)
  		  				       (transpiler-sighten-files tr (list i.)))))))))
  
  (defun target-transpile-save-compiled (tr &key (files-after-deps nil)
  							  	   			   (files-before-deps nil)
  								   			   (dep-gen nil)
  							 	   			   (decl-gen nil))
    (setf (transpiler-re-back-after-deps tr) files-after-deps)
    (setf (transpiler-re-back-before-deps tr) files-before-deps)
    (setf (transpiler-re-dep-gen tr) dep-gen)
    (setf (transpiler-re-decl-gen tr) decl-gen))
  
  (defun target-transpile-generic (tr &key (files-before-deps nil)
  										 (files-after-deps nil)
  