anchor.diff:  	  x))
   
   (define-js-macro %slot-value (x y)
  -  `(,(if (consp x)
  -         x
  -         (transpiler-obfuscated-symbol-string *js-transpiler* x))
  -    "."
  -    ,(if (consp y)
  -         y
  -         (transpiler-obfuscated-symbol-string *js-transpiler* y))))
  +  `(%transpiler-native ,(if (consp x)
  +                            x
  +                            (transpiler-obfuscated-symbol-string *js-transpiler* x))
  +                       "."
  +                       ,(if (consp y)
  +                            y
  +                            (transpiler-obfuscated-symbol-string *js-transpiler* y))))
   
   ;;;; BACK-END META-CODES
   
   (define-js-macro %stack (x)
     (if (transpiler-stack-locals? *js-transpiler*)
  -  	  `("_locals[" ,x "]")
  +  	  `(%transpiler-native "_locals[" ,x "]")
         (js-stack x)))
   
   ;; Experimental for lambda-export.
   (define-js-macro %vec (v i)
  -  `(,v "[" ,i "]"))
  +  `(%transpiler-native ,v "[" ,i "]"))
   
   ;; Experimental for lambda-export.
   (define-js-macro %set-vec (v i x)
  -  `(aref ,v ,i) "=" ,x ,*js-separator*)
  +  `(%transpiler-native (aref ,v ,i) "=" ,x ,*js-separator*))
   
   (define-js-macro %js-typeof (x)
  -  `("typeof " ,x))
  +  `(%transpiler-native "typeof " ,x))
   
   (define-js-macro %%funref (name fi-sym)
     (let fi (get-lambda-funinfo-by-sym fi-sym)
  
positive.code: (define-js-macro %setq (dest val)
    (if (and (not dest)
  		   (atom val))
  	  ""
  	  (js-%setq-0 dest val)))
  
  ;;;; VARIABLE DECLARATIONS
  
  (define-js-macro %var (name)
    `(,*js-indent* "var " ,name ,*js-separator*))
  
  ;;;; TYPE PREDICATES
  
  
negative.code: 
  (defun js-%setq-0 (dest val)
    `(,*js-indent*
  	(%transpiler-native
          ,@(if dest
  		      `(,dest "=")
  		      '("")))
  	,(if (or (atom val)
  			 (codegen-expr? val))
  		 val
  