anchor.diff:        (if (char= c qd) (cons bar baz) (cons (with-input-from-string (x bar) (read x)) baz)))))
   
   (defun mods (s)
  -  "imsxge modifiers"
  +  "imsxg modifiers"
     (coerce (loop for c = (read-char s) while (alpha-char-p c) collect c finally (unread-char c s)) 'string))
   
   (lol:defmacro! sub (o!a o!m)
  
positive.code:            ,altern)))))
  
  (defmacro whenmatch ((test s) &rest conseq) `(ifmatch (,test ,s) (progn ,@conseq)))
  
  
  
  #|
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ; 22.10.15 new lol
  ;;----
  ;;;;;; NEW CODE FOR ANTIWEB
  #+cl-ppcre
  (defun dollar-symbol-p (s)
    (and (symbolp s)
         (> (length (symbol-name s)) 1)
         (string= (symbol-name s)
                  "$"
                  :start1 0
                  :end1 1)
         (ignore-errors (parse-integer (subseq (symbol-name s) 1)))))
  
  (defmacro! if-match ((match-regex str) then &optional else)
    (let* ((dollars (remove-duplicates
                     (remove-if-not #'dollar-symbol-p
                                    (flatten then))))
           (top (or (car (sort (mapcar #'dollar-symbol-p dollars) #'>))
                    0)))
      `(multiple-value-bind (,g!matches ,g!captures) (,match-regex ,str)
         (declare (ignorable ,g!matches ,g!captures))
         (let ((,g!captures-len (length ,g!captures)))
           (declare (ignorable ,g!captures-len))
           (symbol-macrolet ,(mapcar #`(,(symb "$" a1)
                                         (if (< ,g!captures-len ,a1)
                                             (error "Too few matchs: ~a unbound." ,(mkstr "$" a1))
                                             (aref ,g!captures ,(1- a1))))
                                     (loop for i from 1 to top collect i))
             (if ,g!matches
                 ,then
                 ,else))))))
  
  
  (defmacro when-match ((match-regex str) &body forms)
    `(if-match (,match-regex ,str)
       (progn ,@forms)))
  
  ;
  
  |#
  
negative.code:            (ppcre:regex-replace (format nil "(?~a)~a" (remove #\e ,,g!m) ,(car ,g!a)) ,',g!s ,(cadr ,g!a) :simple-calls t)
  					 (ppcre:regex-replace (format nil "(?~a)~a" ,,g!m ,(car ,g!a)) ,',g!s ,(cadr ,g!a)))))))
  
  (lol:defmacro! mat (o!a o!m)
    ``(lambda (,',g!s)
        (if (string= "" ,,g!m)
          (ppcre:scan-to-strings ,(car ,g!a) ,',g!s)
          (ppcre:scan-to-strings (format nil "(?~a)~a" ,,g!m ,(car ,g!a)) ,',g!s))))
  
  (set-dispatch-macro-character #\# #\~
    (lambda (s c n)
      (case (read-char s)
        (#\m (mat (segment-reader s (read-char s) 1) (mods s)))
        (#\s (sub (segment-reader s (read-char s) 2) (mods s)))
        (t (error "Unknown #~~ mode character")))))
  
  (lol:defmacro! ifmatch ((test s) conseq &optional altern)
    (let* ((dollars (remove-duplicates (remove-if-not #'lol:dollar-symbol-p (lol:flatten conseq))))
  