                                       (cljs.compiler/warning &env
                                         (core/str "WARNING: Symbol " % " is not a protocol")))
                                     (cljs.compiler/warning &env
-                                      (core/str "WARNING: Can't resolve protocol symbol " %)))))]
+                                      (core/str "WARNING: Can't resolve protocol symbol " %)))))
+        skip-flag (set (-> tsym meta :skip-protocol-flag))]
     (if (base-type tsym)
       (let [t (base-type tsym)
             assign-impls (fn [[p sigs]]

        fields (vec (map #(with-meta % nil) fields))
        base-fields fields
	fields (conj fields '__meta '__extmap (with-meta '__hash {:mutable true}))
        pmasks (prepare-protocol-masks env tagname impls)
	adorn-params (fn [sig]
                       (cons (vary-meta (second sig) assoc :cljs.compiler/fields fields)
                             (nnext sig)))

                                 (map (fn [[f & meths]]
                                        `(set! ~(symbol (core/str prototype-prefix f)) (fn ~@(map adapt-params meths))))
                                      sigs))
                               (concat (when-not (skip-flag psym)
                                         [`(set! ~(symbol (core/str prototype-prefix pprefix)) true)])
                                       (mapcat (fn [[f & meths]]
                                                 (if (= psym 'cljs.core.IFn)
                                                   (let [adapt-params (fn [[[targ & args :as sig] & body]]
                                                                        (let [tsym (gensym "tsym")]
                                                                          `(~(with-meta (vec (cons tsym args)) (meta sig))
                                                                            (this-as ~tsym
                                                                              (let [~targ ~tsym]
                                                                                ~@body)))))
                                                         meths (map adapt-params meths)
                                                         tsym (gensym "tsym")
                                                         argsym (gensym "args")]
                                                     [`(set! ~(symbol (core/str prototype-prefix 'call)) (fn ~@meths))
                                                      `(set! ~(symbol (core/str prototype-prefix 'apply))
                                                             (fn ~(with-meta [tsym argsym] (meta (first meths)))
                                                               (.apply (.-call ~tsym) ~tsym
                                                                       (.concat (array ~tsym) (aclone ~argsym)))))])
                                                   (let [pf (core/str prototype-prefix pprefix f)]
                                                     (if (vector? (first meths))
                                                       [`(set! ~(symbol (core/str pf "$arity$" (count (first meths)))) (fn ~@meths))]
                                                       (map (fn [[sig & body :as meth]]
                                                              `(set! ~(symbol (core/str pf "$arity$" (count sig)))
                                                                     (fn ~meth)))
                                                            meths)))))
                                               sigs)))))]
        `(do ~@(mapcat assign-impls impl-map))))))

(defn- prepare-protocol-masks [env t impls]
