anchor.diff:    (class (nym &rest terms)
       (cofy nym)
       (csyn '***curr-class*** nym)
  -    (format nil "class ~a~a" nym (block-c terms)))
  +    (format nil "class ~a~a" nym (if terms (block-c terms) "")))
     (protected (&rest terms)
       (cofsy terms)
       (format nil "protected:~%~a" (block-c terms nil)))
  
positive.code:                     (mapcar #'(lambda (xs)
                          (format nil "~a(~a)"
                                  (cof (car xs))
                                  (cof (cadr xs))))
                        init-pairs))
                  "")
              (block-c code)))
    (destroy (args &rest code)
      (format nil "~~~a(~a)~a"
              (cof '***curr-class***)
              (vars-c args)
              (block-c code)))
    (operator (oper &optional typ args &rest code)
      (let ((opr "operator"))
              (cofy typ)
              (if (listp oper)
                  (if (member (car oper) '(ns namespace n/c))
                      (progn
                        (setf opr
                            (apply
                              #'namespace-c
                              (append (butlast (cdr oper)) (list opr))))
                        (setf oper (car (last oper))))))
              (setf oper (string-downcase (strof oper))) 
        (format nil "~a ~a~a~a(~a)~a"
                typ opr (if (alphap (char (strof oper) 0)) " " "") oper (vars-c args) (if code (block-c code) ""))))
  
negative.code: (defun camelcase-c (&rest strs)
    (setf strs
          (flatten (mapcan #'(lambda (x) (split-str x #\-)) (mapcar #'strof strs))))
    (setf strs
          (flatten (mapcan #'(lambda (x) (split-str x #\_)) (mapcar #'strof strs))))
    (format nil "~{~a~}" (mapcar #'capitalize-c strs)))
  
  (defun dashify-c (&rest strs)
  