Current File : //kunden/usr/share/emacs/27.2/lisp/erc/erc-backend.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\303!\210\300\304!\207" [require erc-compat provide erc-backend erc] 2)
#@61 Hash table mapping server responses to their handler hooks.
(defvar erc-server-responses (make-hash-table :test 'equal) (#$ . 509))
#@71 compiler-macro for inlining `erc-response-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'erc-response-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block erc-response-p (and (memq (type-of cl-x) cl-struct-erc-response-tags) t)) nil] 9 (#$ . 647)])
(put 'erc-response-p 'compiler-macro 'erc-response-p--cmacro)
#@13 

(fn CL-X)
(defalias 'erc-response-p #[257 "\301
!>\205	\302\207" [cl-struct-erc-response-tags type-of t] 3 (#$ . 992)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put erc-response-p side-effect-free error-free put erc-response cl-deftype-satisfies] 5)
#@78 compiler-macro for inlining `erc-response.unparsed'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'erc-response\.unparsed--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block erc-response\.unparsed (progn (or (erc-response-p cl-x) (signal 'wrong-type-argument (list 'erc-response cl-x))) (aref cl-x 1))) nil] 9 (#$ . 1273)])
(put 'erc-response\.unparsed 'compiler-macro 'erc-response\.unparsed--cmacro)
#@66 Access slot "unparsed" of `erc-response' struct CL-X.

(fn CL-X)
(defalias 'erc-response\.unparsed #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 1] 5 (#$ . 1705)])
(byte-code "\300\301\302\303#\300\207" [function-put erc-response\.unparsed side-effect-free t] 4)
#@76 compiler-macro for inlining `erc-response.sender'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'erc-response\.sender--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block erc-response\.sender (progn (or (erc-response-p cl-x) (signal 'wrong-type-argument (list 'erc-response cl-x))) (aref cl-x 2))) nil] 9 (#$ . 2061)])
(put 'erc-response\.sender 'compiler-macro 'erc-response\.sender--cmacro)
#@64 Access slot "sender" of `erc-response' struct CL-X.

(fn CL-X)
(defalias 'erc-response\.sender #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 2] 5 (#$ . 2483)])
(byte-code "\300\301\302\303#\300\207" [function-put erc-response\.sender side-effect-free t] 4)
#@77 compiler-macro for inlining `erc-response.command'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'erc-response\.command--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block erc-response\.command (progn (or (erc-response-p cl-x) (signal 'wrong-type-argument (list 'erc-response cl-x))) (aref cl-x 3))) nil] 9 (#$ . 2833)])
(put 'erc-response\.command 'compiler-macro 'erc-response\.command--cmacro)
#@65 Access slot "command" of `erc-response' struct CL-X.

(fn CL-X)
(defalias 'erc-response\.command #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 3] 5 (#$ . 3260)])
(byte-code "\300\301\302\303#\300\207" [function-put erc-response\.command side-effect-free t] 4)
#@82 compiler-macro for inlining `erc-response.command-args'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'erc-response\.command-args--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block erc-response\.command-args (progn (or (erc-response-p cl-x) (signal 'wrong-type-argument (list 'erc-response cl-x))) (aref cl-x 4))) nil] 9 (#$ . 3613)])
(put 'erc-response\.command-args 'compiler-macro 'erc-response\.command-args--cmacro)
#@70 Access slot "command-args" of `erc-response' struct CL-X.

(fn CL-X)
(defalias 'erc-response\.command-args #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4] 5 (#$ . 4065)])
(byte-code "\300\301\302\303#\300\207" [function-put erc-response\.command-args side-effect-free t] 4)
#@78 compiler-macro for inlining `erc-response.contents'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'erc-response\.contents--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block erc-response\.contents (progn (or (erc-response-p cl-x) (signal 'wrong-type-argument (list 'erc-response cl-x))) (aref cl-x 5))) nil] 9 (#$ . 4433)])
(put 'erc-response\.contents 'compiler-macro 'erc-response\.contents--cmacro)
#@66 Access slot "contents" of `erc-response' struct CL-X.

(fn CL-X)
(defalias 'erc-response\.contents #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 5] 5 (#$ . 4865)])
(byte-code "\300\301\302\303#\300\207" [function-put erc-response\.contents side-effect-free t] 4)
#@74 compiler-macro for inlining `erc-response.tags'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'erc-response\.tags--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block erc-response\.tags (progn (or (erc-response-p cl-x) (signal 'wrong-type-argument (list 'erc-response cl-x))) (aref cl-x 6))) nil] 9 (#$ . 5221)])
(put 'erc-response\.tags 'compiler-macro 'erc-response\.tags--cmacro)
#@62 Access slot "tags" of `erc-response' struct CL-X.

(fn CL-X)
(defalias 'erc-response\.tags #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 6] 5 (#$ . 5633)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put erc-response\.tags side-effect-free t defalias copy-erc-response copy-sequence] 4)
#@131 compiler-macro for inlining `make-erc-response'.

(fn CL-WHOLE &cl-quote &key UNPARSED SENDER COMMAND COMMAND-ARGS CONTENTS TAGS)
(defalias 'make-erc-response--cmacro #[385 "\300
\301\"\206\302A@\300\303\"\206\304A@\300\305\"\206\306A@\300\307\"\206&\310A@\300\311\"\2060\312A@\300\313\"\206;\314A@\211\203j\211@\315>\203R\211AA\262
\202?\316>A@\203a\317\262
\202?\320\321@\"\210\202?\210\322\323\324\317\317&\207" [plist-member :unparsed (nil #1="") :sender (nil #1#) :command (nil #1#) :command-args (nil 'nil) :contents (nil #1#) :tags (nil 'nil) (:unparsed :sender :command :command-args :contents :tags :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:unparsed :sender :command :command-args :contents :tags)" cl--defsubst-expand (unparsed sender command command-args contents tags) (cl-block make-erc-response (record 'erc-response unparsed sender command command-args contents tags))] 20 (#$ . 6029)])
(put 'make-erc-response 'compiler-macro 'make-erc-response--cmacro)
#@111 Constructor for objects of type `erc-response'.

(fn &key UNPARSED SENDER COMMAND COMMAND-ARGS CONTENTS TAGS)
(defalias 'make-erc-response #[128 "\300
\301\"\206\302A@\300\303\"\206\304A@\300\305\"\206\306A@\300\307\"\206&\310A@\300\311\"\2060\312A@\300\313\"\206;\314A@\211\203j\211@\315>\203R\211AA\262
\202?\316>A@\203a\317\262
\202?\320\321@\"\210\202?\210\322\323&\207" [plist-member :unparsed (nil #1="") :sender (nil #1#) :command (nil #1#) :command-args (nil nil) :contents (nil #1#) :tags (nil nil) (:unparsed :sender :command :command-args :contents :tags :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:unparsed :sender :command :command-args :contents :tags)" record erc-response] 15 (#$ . 7086)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-erc-response side-effect-free t cl-struct-define erc-response nil cl-structure-object record ((cl-tag-slot) (unparsed #1="" :type string) (sender #1# :type string) (command #1# :type string) (command-args 'nil :type list) (contents #1# :type string) (tags 'nil :type list)) cl-struct-erc-response-tags] 11)
#@72 Nickname on the current server.
Use `erc-current-nick' to access this.
(defvar erc-server-current-nick nil (#$ . 8277))
(make-variable-buffer-local 'erc-server-current-nick)
#@60 The process object of the corresponding server connection.
(defvar erc-server-process nil (#$ . 8457))
(make-variable-buffer-local 'erc-server-process)
#@54 The server name used to connect to for this session.
(defvar erc-session-server nil (#$ . 8615))
(make-variable-buffer-local 'erc-session-server)
#@69 The function used to connect to this session (nil for the default).
(defvar erc-session-connector nil (#$ . 8767))
(make-variable-buffer-local 'erc-session-connector)
#@30 The port used to connect to.
(defvar erc-session-port nil (#$ . 8940))
(make-variable-buffer-local 'erc-session-port)
#@39 The name the server announced to use.
(defvar erc-server-announced-name nil (#$ . 9064))
(make-variable-buffer-local 'erc-server-announced-name)
#@44 The name and version of the server's ircd.
(defvar erc-server-version nil (#$ . 9215))
(make-variable-buffer-local 'erc-server-version)
#@1060 Alist listing the supported server parameters.

This is only set if the server sends 005 messages saying what is
supported on the server.

Entries are of the form:
  (PARAMETER . VALUE)
or
  (PARAMETER) if no value is provided.

Some examples of possible parameters sent by servers:
CHANMODES=b,k,l,imnpst - list of supported channel modes
CHANNELLEN=50 - maximum length of channel names
CHANTYPES=#&!+ - supported channel prefixes
CHARMAPPING=rfc1459 - character mapping used for nickname and channels
KICKLEN=160 - maximum allowed kick message length
MAXBANS=30 - maximum number of bans per channel
MAXCHANNELS=10 - maximum number of channels allowed to join
NETWORK=EFnet -  the network identifier
NICKLEN=9 - maximum allowed length of nicknames
PREFIX=(ov)@+ - list of channel modes and the user prefixes if user has mode
RFC2812 - server supports RFC 2812 features
SILENCE=10 - supports the SILENCE command, maximum allowed number of entries
TOPICLEN=160 - maximum allowed topic length
WALLCHOPS - supports sending messages to all operators in a channel
(defvar erc-server-parameters nil (#$ . 9359))
(make-variable-buffer-local 'erc-server-parameters)
#@57 Mapping of server buffers to their specific ping timer.
(defvar erc-server-ping-timer-alist nil (#$ . 10523))
#@210 Non-nil if the current buffer has been used by ERC to establish
an IRC connection.

If you wish to determine whether an IRC connection is currently
active, use the `erc-server-process-alive' function instead.
(defvar erc-server-connected nil (#$ . 10640))
(make-variable-buffer-local 'erc-server-connected)
#@68 Number of times we have failed to reconnect to the current server.
(defvar erc-server-reconnect-count 0 (#$ . 10953))
(make-variable-buffer-local 'erc-server-reconnect-count)
#@38 Non-nil if the user requests a quit.
(defvar erc-server-quitting nil (#$ . 11134))
(make-variable-buffer-local 'erc-server-quitting)
#@97 Non-nil if the user requests an explicit reconnect, and the
current IRC process is still alive.
(defvar erc-server-reconnecting nil (#$ . 11273))
(make-variable-buffer-local 'erc-server-reconnecting)
#@56 Non-nil if the IRC server failed to respond to a ping.
(defvar erc-server-timed-out nil (#$ . 11479))
(make-variable-buffer-local 'erc-server-timed-out)
#@63 Non-nil if the user is denied access because of a server ban.
(defvar erc-server-banned nil (#$ . 11638))
(make-variable-buffer-local 'erc-server-banned)
#@49 Non-nil if the user triggers some server error.
(defvar erc-server-error-occurred nil (#$ . 11798))
(make-variable-buffer-local 'erc-server-error-occurred)
#@15 Line counter.
(defvar erc-server-lines-sent nil (#$ . 11960))
(make-variable-buffer-local 'erc-server-lines-sent)
#@91 Last peers used, both sender and receiver.
Those are used for /MSG destination shortcuts.
(defvar erc-server-last-peers '(nil) (#$ . 12080))
(make-variable-buffer-local 'erc-server-last-peers)
#@65 Time the message was sent.
This is useful for flood protection.
(defvar erc-server-last-sent-time nil (#$ . 12279))
(make-variable-buffer-local 'erc-server-last-sent-time)
#@67 Time the last ping was sent.
This is useful for flood protection.
(defvar erc-server-last-ping-time nil (#$ . 12457))
(make-variable-buffer-local 'erc-server-last-ping-time)
#@100 Time the last message was received from the server.
This is useful for detecting hung connections.
(defvar erc-server-last-received-time nil (#$ . 12638))
(make-variable-buffer-local 'erc-server-last-received-time)
#@86 Calculated server lag time in seconds.
This variable is only set in a server buffer.
(defvar erc-server-lag nil (#$ . 12859))
(make-variable-buffer-local 'erc-server-lag)
#@71 The data that arrived from the server
but has not been processed yet.
(defvar erc-server-filter-data nil (#$ . 13036))
(make-variable-buffer-local 'erc-server-filter-data)
#@53 Internal variable used to track duplicate messages.
(defvar erc-server-duplicates (make-hash-table :test 'equal) (#$ . 13214))
(make-variable-buffer-local 'erc-server-duplicates)
#@498 Non-nil when we're currently processing a message.

When ERC receives a private message, it sets up a new buffer for
this query.  These in turn, though, do start flyspell.  This
involves starting an external process, in which case Emacs will
wait - and when it waits, it does accept other stuff from, say,
network exceptions.  So, if someone sends you two messages
quickly after each other, ispell is started for the first, but
might take long enough for the second message to be processed
first.
(defvar erc-server-processing-p nil (#$ . 13400))
(make-variable-buffer-local 'erc-server-processing-p)
#@116 When we sent the last message.
See `erc-server-flood-margin' for an explanation of the flood
protection algorithm.
(defvar erc-server-flood-last-message 0 (#$ . 14008))
(make-variable-buffer-local 'erc-server-flood-last-message)
#@141 The queue of messages waiting to be sent to the server.
See `erc-server-flood-margin' for an explanation of the flood
protection algorithm.
(defvar erc-server-flood-queue nil (#$ . 14244))
(make-variable-buffer-local 'erc-server-flood-queue)
#@30 The timer to resume sending.
(defvar erc-server-flood-timer nil (#$ . 14492))
(byte-code "\300\301!\210\302\303\304\305\306\307%\210\310\311\312\313\314DD\315\306\303\316\317&\210\310\320\312\313\321DD\322\306\303\316\323&\210\310\324\312\313\325DD\326\306\303\316\327&\210\310\330\312\313\331DD\332\316\333\306\303&\210\310\334\312\313\335DD\336\306\303\337\340\316\341&	\210\310\342\312\313\343DD\344\306\303\316\345&\210\310\346\312\313\347DD\350\306\303\316\351&\210\310\352\312\313\353DD\354\306\303\316\313&\210\310\355\312\313\356DD\357\316\360\306\303&\210\310\361\312\313\362DD\363\316\333\306\303&\210\310\364\312\313\365DD\366\337\367\316\370\306\303&	\210\310\371\312\313\372DD\373\316\333\306\303&\210\310\374\312\313\375DD\376\316\333\306\303&\210\310\377\312\313\201@DD\201A\306\303\316\201B&\210\310\201C\312\313\201DDD\201E\306\303\316\201F&\207" [make-variable-buffer-local erc-server-flood-timer custom-declare-group erc-server nil "Parameters for dealing with IRC servers." :group erc custom-declare-variable erc-server-auto-reconnect funcall function #[0 "\300\207" [t] 1] "Non-nil means that ERC will attempt to reestablish broken connections.\n\nReconnection will happen automatically for any unexpected disconnection." :type boolean erc-server-reconnect-attempts #[0 "\300\207" [2] 1] "The number of times that ERC will attempt to reestablish a\nbroken connection, or t to always attempt to reconnect.\n\nThis only has an effect if `erc-server-auto-reconnect' is non-nil." (choice (const :tag "Always reconnect" t) integer) erc-server-reconnect-timeout #[0 "\300\207" [1] 1] "The amount of time, in seconds, that ERC will wait between\nsuccessive reconnect attempts.\n\nIf a key is pressed while ERC is waiting, it will stop waiting." number erc-split-line-length #[0 "\300\207" [440] 1] "The maximum length of a single message.\nIf a message exceeds this size, it is broken into multiple ones.\n\nIRC allows for lines up to 512 bytes.  Two of them are CR LF.\nAnd a typical message looks like this:\n\n  :nicky!uhuser@host212223.dialin.fnordisp.net PRIVMSG #lazybastards :Hello!\n\nYou can limit here the maximum length of the \"Hello!\" part.\nGood luck." integer erc-coding-system-precedence #[0 "\300\207" [(utf-8 undecided)] 1] "List of coding systems to be preferred when receiving a string from the server.\nThis will only be consulted if the coding system in\n`erc-server-coding-system' is `undecided'." :version "24.1" (repeat coding-system) erc-server-coding-system #[0 "\300\301!\205\301\302!\205\301\303!\205\304\207" [fboundp coding-system-p undecided utf-8 (utf-8 . undecided)] 2] "The default coding system for incoming and outgoing text.\nThis is either a coding system, a cons, a function, or nil.\n\nIf a cons, the encoding system for outgoing text is in the car\nand the decoding system for incoming text is in the cdr.  The most\ninteresting use for this is to put `undecided' in the cdr.  This\nmeans that `erc-coding-system-precedence' will be consulted, and the\nfirst match there will be used.\n\nIf a function, it is called with the argument `target' and should\nreturn a coding system or a cons as described above.\n\nIf you need to send non-ASCII text to people not using a client that\ndoes decoding on its own, you must tell ERC what encoding to use.\nEmacs cannot guess it, since it does not know what the people on the\nother end of the line are using." (choice (const :tag "None" nil) coding-system (cons (coding-system :tag "encoding" :value utf-8) (coding-system :tag "decoding" :value undecided)) function) erc-encoding-coding-alist #[0 "\300\207" [nil] 1] "Alist of target regexp and coding-system pairs to use.\nThis overrides `erc-server-coding-system' depending on the\ncurrent target as returned by `erc-default-target'.\n\nExample: If you know that the channel #linux-ru uses the coding-system\n`cyrillic-koi8', then add (\"#linux-ru\" . cyrillic-koi8) to the\nalist." (repeat (cons (string :tag "Target") coding-system)) erc-server-connect-function #[0 "\300\207" [erc-open-network-stream] 1] "Function used to initiate a connection.\nIt should take same arguments as `open-network-stream' does." erc-server-prevent-duplicates #[0 "\300\207" [("301")] 1] "Either nil or a list of strings.\nEach string is a IRC message type, like PRIVMSG or NOTICE.\nAll Message types in that list of subjected to duplicate prevention." (choice (const nil) (list string)) erc-server-duplicate-timeout #[0 "\300\207" [60] 1] "The time allowed in seconds between duplicate messages.\n\nIf two identical messages arrive within this value of one another, the second\nisn't displayed." erc-server-timestamp-format #[0 "\300\207" [#1="%Y-%m-%d %T"] 1 #1#] "Timestamp format used with server response messages.\nThis string is processed using `format-time-string'." "24.3" string erc-server-flood-margin #[0 "\300\207" [10] 1] "A margin on how much excess data we send.\nThe flood protection algorithm of ERC works like the one\ndetailed in RFC 2813, section 5.8 \"Flood control of clients\".\n\n  * If `erc-server-flood-last-message' is less than the current\n    time, set it equal.\n  * While `erc-server-flood-last-message' is less than\n    `erc-server-flood-margin' seconds ahead of the current\n    time, send a message, and increase\n    `erc-server-flood-last-message' by\n    `erc-server-flood-penalty' for each message." erc-server-flood-penalty #[0 "\300\207" [3] 1] "How much we penalize a message.\nSee `erc-server-flood-margin' for an explanation of the flood\nprotection algorithm." erc-server-send-ping-interval #[0 "\300\207" [30] 1] "Interval of sending pings to the server, in seconds.\nIf this is set to nil, pinging the server is disabled." (choice (const :tag "Disabled" nil) (integer :tag "Seconds")) erc-server-send-ping-timeout #[0 "\300\207" [120] 1] "If the time between ping and response is greater than this, reconnect.\nThe time is in seconds.\n\nThis must be greater than or equal to the value for\n`erc-server-send-ping-interval'.\n\nIf this is set to nil, never try to reconnect." (choice (const :tag "Disabled" nil) (integer :tag "Seconds"))] 10)
#@46 This variable holds the periodic ping timer.
(defvar erc-server-ping-handler nil (#$ . 20648))
(make-variable-buffer-local 'erc-server-ping-handler)
#@170 Return a list of lines which are not too long for IRC.
The length is specified in `erc-split-line-length'.

Currently this is called by `erc-send-input'.

(fn LONGLINE)
(defalias 'erc-split-line #[257 "\302\303!\211:\203
\211@\202\211\304\305!r\211q\210\306\307\310\311\312!\313\"\314$\216c\210\315ed#\210\316ed\303\317$\210)\320ed#\210\321\322 \323\"*\262
\207" [erc-split-line-length fill-column erc-coding-system-for-target nil generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 encode-coding-region fill-region t decode-coding-region split-string buffer-string "\n"] 10 (#$ . 20804)])
#@114 Move forward one word, ignoring any subword settings.
If no subword-mode is active, then this is (forward-word).
(defalias 'erc-forward-word #[0 "\300\301!\210\300\302!\303V\207" [skip-syntax-forward "^w" "w" 0] 2 (#$ . 21479)])
#@112 Report whether the char after a given POS has word syntax.
If POS is out of range, the value is nil.

(fn POS)
(defalias 'erc-word-at-arg-p #[257 "\211f\211\205\n\211z\300=\207" [119] 4 (#$ . 21715)])
#@145 Return the bounds of word at point, or nil if we're not at a word.
If no subword-mode is active, then this is
(bounds-of-thing-at-point 'word).
(defalias 'erc-bounds-of-word-at-point #[0 "\300`!\204
\300`S!\205\212\301\302!\210`\303\302!\210`

B\266\202)\207" [erc-word-at-arg-p skip-syntax-backward "w" skip-syntax-forward] 4 (#$ . 21924)])
#@41 Upcase the first word in STR.

(fn STR)
(defalias 'erc-upcase-first-word #[257 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216
c\210eb\210\311`\312 \210`\"\210\313 *\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 upcase-region erc-forward-word buffer-string] 8 (#$ . 22275)])
#@109 Set up a timer to periodically ping the current server.
The current buffer is given by BUFFER.

(fn BUFFER)
(defalias 'erc-server-setup-periodical-ping #[257 "r\211q\210\203\f\303!\210	\2056\304\305	\306$\211\n\236\211\203.\303
A!\210
\n\236\211\241\262
\2024\307\302B\"\262
)\207" [erc-server-ping-handler erc-server-send-ping-interval erc-server-ping-timer-alist erc-cancel-timer run-with-timer 4 erc-server-send-ping add-to-list] 6 (#$ . 22648)])
#@96 Return non-nil when BUFFER has an `erc-server-process' open or running.

(fn &optional BUFFER)
(defalias 'erc-server-process-alive #[256 "r\211\206pq\210\205\301!\205\302!\303>)\207" [erc-server-process processp process-status (run open)] 3 (#$ . 23115)])
#@83 As `open-network-stream', but does non-blocking IO

(fn NAME BUFFER HOST SERVICE)
(defalias 'erc-open-network-stream #[1028 "\300\301\302\303\304\305\306&\n\207" [make-network-process :name :buffer :host :service :nowait t] 15 (#$ . 23386)])
#@158 Perform the connection and login using the specified SERVER and PORT.
We will store server variables in the buffer given by BUFFER.

(fn SERVER PORT BUFFER)
(defalias 'erc-server-connect #[771 "\306\307\310\311%\312\313\314\"\210\315\316#\312$\262
\317
!\204(\320\321!\210rq\210\211\312\211\312\211\312'\322 \211(\211)*\323+\324,)\325\326!\203U\326
\327\"\210\330
\331\"\210\332
\333\"\210\334
\"\210-\203m\335\336!\210\313\314\306\337\340rq\210\341 )#\"\210\342
!\307=\203\216\343\312\211\344$\202\225\313\345\"\210\346 \207" [erc-server-connect-function erc-server-process erc-server-quitting erc-server-reconnecting erc-server-timed-out erc-server-banned erc-format-message connect 83 112 nil message "%s" format "erc-%s-%s" processp error "Connection attempt failed" erc-current-time 0 (nil) fboundp set-process-coding-system raw-text set-process-sentinel erc-process-sentinel set-process-filter erc-server-filter-function set-process-buffer erc-log-aux "\n\n\n********************************************\n" login 110 erc-current-nick process-status erc-display-message "Opening connection..\n" "%s...done" erc-login erc-server-error-occurred erc-server-last-sent-time erc-server-last-ping-time erc-server-last-received-time erc-server-lines-sent erc-server-last-peers erc-log-p] 12 (#$ . 23642)])
#@95 Reestablish the current IRC connection.
Make sure you are in an ERC buffer when running this.
(defalias 'erc-server-reconnect #[0 "\306 \307
!\204\310=\203p\262
\202\311\312!\210r\211q\210\313 \210\314p!\210\315\211\206,\316\317
\320&*\207" [major-mode erc-server-last-sent-time erc-server-lines-sent erc-session-connector erc-server-connect-function erc-session-server erc-server-buffer buffer-live-p erc-mode error "Reconnect must be run from an ERC buffer" erc-update-mode-line erc-set-active-buffer 0 erc-open-network-stream erc-open t erc-session-port erc-server-current-nick erc-session-user-full-name erc-session-password] 9 (#$ . 24987)])
#@15 

(fn BUFFER)
(defalias 'erc-server-delayed-reconnect #[257 "\300
!\205
r\211q\210\301 )\207" [buffer-live-p erc-server-reconnect] 3 (#$ . 25661)])
#@61 The process filter for the ERC server.

(fn PROCESS STRING)
(defalias 'erc-server-filter-function #[514 "r\303!q\210\304 	\203\n\203\n
P\202\211\211\202Z\305\n\203)\n
P\202*\211\n\205Y\306\307\n\"\205Y\310\n\311\211\224#\311\225\nGU?\205J\310\n\311\225\"\312
\313\"\210\314\"\266\202+))\207" [erc-server-last-received-time erc-server-processing-p erc-server-filter-data process-buffer erc-current-time t string-match "[\n
]+" substring 0 erc-log-irc-protocol nil erc-parse-server-response] 6 (#$ . 25816)])
#@144 Return non-nil if ERC should attempt to reconnect automatically.
EVENT is the message received from the closed connection process.

(fn EVENT)
(defalias 'erc-server-reconnect-p #[257 "\2064	\2054\n?\2054\306=\204\250\2054\fW\2054
\204*\307\310\"?\2054\307\311\"\2033\312\207\306\207" [erc-server-reconnecting erc-server-auto-reconnect erc-server-banned erc-server-reconnect-attempts erc-server-reconnect-count erc-server-timed-out t string-match "^deleted" "^failed with code 111" nonblocking] 4 (#$ . 26352)])
(byte-code "\300\301\302\303#\300\207" [function-put erc-server-reconnect-p compiler-macro erc-server-reconnect-p--inliner] 4)
#@27 

(fn INLINE--FORM EVENT)
(defalias 'erc-server-reconnect-p--inliner #[514 "\3002T\211\301
!\203\211\202\302\303!\304\305\306\307\310\311D\304\312\313\314E\306\315\313D\316\317\313EEE\304\320\310\321\322EDE\323\321\324\nE\325\326D\314F\257E
=\203J\211\202Q\327DC\"\266\2030\207" [inline--just-use macroexp-copyable-p make-symbol "event" or erc-server-reconnecting and erc-server-auto-reconnect not erc-server-banned eq erc-server-reconnect-attempts t integerp < erc-server-reconnect-count erc-server-timed-out string-match "^deleted" if "^failed with code 111" quote nonblocking macroexp-let*] 16 (#$ . 27012)])
#@96 Called when `erc-process-sentinel-1' has detected an unexpected disconnect.

(fn EVENT BUFFER)
(defalias 'erc-process-sentinel-2 #[514 "\306
!\204	\307 \207r\211q\210\206C	\205C\n?\205C\310=\204+\250\205C\fW\205C
\2047\311\312\"?\205C\311\313\"\203B\314\202C\310\315\211\203M\316\202N\317\262\320\315\321p$\210\204o\320\315\321p\322\323\n&\210\307 \210\324\315!\202\226\3251\207\315\fT\262
\326
\315\327$0\202\226\210\250\204\223\330\331\332\333#\210\327!\266\203)\207" [erc-server-reconnecting erc-server-auto-reconnect erc-server-banned erc-server-reconnect-attempts erc-server-reconnect-count erc-server-timed-out buffer-live-p erc-update-mode-line t string-match "^deleted" "^failed with code 111" nonblocking nil disconnected disconnected-noreconnect erc-display-message error terminated 101 set-buffer-modified-p (error) run-at-time erc-server-delayed-reconnect message "%s ... %s" "Reconnecting until we succeed" "kill the ERC server buffer to stop" erc-server-reconnect-timeout] 12 (#$ . 27645)])
#@221 Called when `erc-process-sentinel' has decided that we're disconnecting.
Determine whether user has quit or whether erc has been terminated.
Conditionally try to reconnect and take appropriate action.

(fn EVENT BUFFER)
(defalias 'erc-process-sentinel-1 #[514 "r\211q\210\203 \302\303\304p\305$\210\306 \210\307\303!\210	\205$\310p!\202$\311\")\207" [erc-server-quitting erc-kill-server-buffer-on-quit erc-display-message nil error finished erc-update-mode-line set-buffer-modified-p kill-buffer erc-process-sentinel-2] 7 (#$ . 28695)])
#@54 Sentinel function for ERC process.

(fn CPROC EVENT)
(defalias 'erc-process-sentinel #[514 "\305!\306
!\205r\211q\210\203\307\310\311\312!	%!\210\313\314\"\203+\315 \202~\316\317\320\321\"\"\266\n\203@\322\n!\210\316\323\324\325 \326 \327$\210\330\331\"\211\203d\211@r\211q\210\332\333\334\")
A\266\202\202M\210\335\f!\206ldb\210\336y\210\337`d\"\210`d|\210\340\")\207" [erc-log-p erc-server-quitting erc-server-ping-handler erc-channel-users erc-input-marker process-buffer buffer-live-p erc-log-aux format "SENTINEL: proc: %S    status: %S  event: %S (quitting: %S)" process-status string-match "^open" erc-login nil mapcar #[257 "r\211q\210\301\211)\207" [erc-server-connected nil] 3 "\n\n(fn BUFFER)"] erc-buffer-list erc-cancel-timer run-hook-with-args erc-disconnected-hook erc-current-nick system-name "" erc-buffer-filter #[0 "\300\301!\207" [boundp erc-channel-users] 2] make-hash-table :test equal marker-position 0 erc-remove-text-properties-region erc-process-sentinel-1] 10 (#$ . 29244)])
#@158 Return the coding system or cons cell appropriate for TARGET.
This is determined via `erc-encoding-coding-alist' or
`erc-server-coding-system'.

(fn TARGET)
(defalias 'erc-coding-system-for-target #[257 "\211\204\303 \262
\211\2035\304\30521	\211\205.\211@\306
@\"\203'\307\305A\"\210
A\266\202\202\262
0)\206B\310\n!\203A\n
!\206B\n\207" [case-fold-search erc-encoding-coding-alist erc-server-coding-system erc-default-target t match string-match throw functionp] 6 (#$ . 30281)])
#@161 Decode STR as appropriate for TARGET.
This is indicated by `erc-encoding-coding-alist', defaulting to the
value of `erc-server-coding-system'.

(fn STR TARGET)
(defalias 'erc-decode-string-from-target #[514 "
;\204\301\262\302
!\211:\203\211A\262
\211\303=\203;\304!\211\2031\211@>\2041\211
A\266\202\202\211\2039\211@\262\266\305\"\207" [erc-coding-system-precedence "" erc-coding-system-for-target undecided detect-coding-string erc-decode-coding-string] 7 (#$ . 30784)])
#@127 Send TEXT to the current server.  Wrapping and flood control apply.
Use DISPLAY-FN to show the results.

(fn TEXT DISPLAY-FN)
(defalias 'erc-send-line #[514 "\300\301\302\303\304\305!\306\"\307\310%\311!\"\207" [mapc make-byte-code 257 "\301
!\210\300 \207" vconcat vector [erc-server-send] 3 "\n\n(fn LINE)" erc-split-line] 9 (#$ . 31283)])
#@431 Send STRING to the current server.
If FORCEP is non-nil, no flood protection is done - the string is
sent directly.  This might cause the messages to arrive in a wrong
order.

If TARGET is specified, look up encoding information for that
channel in `erc-encoding-coding-alist' or
`erc-server-coding-system'.

See `erc-server-flood-margin' for an explanation of the flood
protection algorithm.

(fn STRING &optional FORCEP TARGET)
(defalias 'erc-server-send #[769 "\203\306\307\310\311 \312\260!\210\313 \314
!\211:\203\211@\262
\315 \203s\316 \317
!\205nr\211q\210\320P\203_\n\\\321
\322\"\210\3231W\324\325!\203O\325\f\326#\210\327\f\"0\202[\210\202k\210\202k\330
BC\"\331p!\210\210)\332\262
\202x\333\334!\210\335\207" [erc-log-p erc-server-last-sent-time erc-server-flood-penalty erc-server-flood-last-message erc-server-process erc-server-flood-queue erc-log-aux "erc-server-send: " "(" buffer-name ")" erc-current-time erc-coding-system-for-target erc-server-process-alive erc-server-buffer buffer-live-p "
\n" erc-log-irc-protocol outbound (error) fboundp set-process-coding-system raw-text process-send-string append erc-server-send-queue t message "ERC: No process running" nil] 10 (#$ . 31635)])
#@111 Send a ping to the IRC server buffer in BUF.
Additionally, detect whether the IRC process has hung.

(fn BUF)
(defalias 'erc-server-send-ping #[257 "\305
!\2031r\211q\210)\2031r\211q\210	\203(\306	\307!\"\203(\310\311!\202/\312\313\314\315 \"!)\207\211\f\236\211\205@\316
A!\210\211\317\241\207" [erc-server-last-received-time erc-server-send-ping-timeout erc-server-timed-out erc-server-process erc-server-ping-timer-alist buffer-live-p time-less-p time-since t delete-process erc-server-send format "PING %.0f" erc-current-time erc-cancel-timer nil] 5 (#$ . 32873)])
#@141 Send messages in `erc-server-flood-queue'.
See `erc-server-flood-margin' for an explanation of the flood
protection algorithm.

(fn BUFFER)
(defalias 'erc-server-send-queue #[257 "r\211q\210\306 \203\307!\210\310\311	\"\203\312
!\n\203u\311	\313\"\"\203u\n@@\n@A\nA	\f\\\314\315\"\210
\203L\316\317\320\321!\322\260!\210\323 \203p\3241k\325\326!\203b\326\327#\210\330\"0\202o\210\202p\210\266\202\n\205\203\331\332\f\\\310\333$\211\262
)\207" [erc-server-flood-timer erc-server-flood-last-message erc-server-flood-queue erc-server-flood-margin erc-server-flood-penalty erc-log-p current-time erc-cancel-timer nil time-less-p erc-emacs-time-to-erc-time time-add erc-log-irc-protocol outbound erc-log-aux "erc-server-send-queue: " "(" buffer-name ")" erc-server-process-alive (error) fboundp set-process-coding-system raw-text process-send-string run-at-time 0.2 erc-server-send-queue erc-server-process] 10 (#$ . 33459)])
#@306 Send LINE to the server as a privmsg or a notice.
MESSAGE-COMMAND should be either "PRIVMSG" or "NOTICE".
If the target is ",", the last person you've got a message from will
be used.  If the target is ".", the last person you've sent a message
to will be used.

(fn MESSAGE-COMMAND LINE &optional FORCE)
(defalias 'erc-message #[770 "\302\303\"\203k\304\305\"\304\306\"\203\307\310\311$!\210
\312\230\2035	@\203/	@\262\202J\313\262\202J
\314\230\203J	A\203G	A\262\202J\313\262
\203`	\241\210\315\310\316$\"\210\202g\317\313\320p\321$\210\266\322\207\313\207" [erc-log-p erc-server-last-peers string-match "^\\s-*\\(\\S-+\\) ?\\(.*\\)" match-string 1 2 erc-log-aux format "cmd: MSG(%s): [%s] %s" "," nil "." erc-server-send "%s %s :%s" erc-display-message error no-target t] 11 (#$ . 34425)])
#@189 Send CTCP message L to TGT.

If TGT is nil the message is not sent.
The command must contain neither a prefix nor a trailing `\n'.

See also `erc-server-send'.

(fn TGT L &optional FORCE)
(defalias 'erc-send-ctcp-message #[770 "\301!\205\203\302\303\304#!\210\305\303\306#\"\207" [erc-log-p erc-upcase-first-word erc-log-aux format "erc-send-CTCP-message: [%s] %s" erc-server-send "PRIVMSG %s :
%s
"] 9 (#$ . 35256)])
#@188 Send CTCP notice L to TGT.

If TGT is nil the message is not sent.
The command must contain neither a prefix nor a trailing `\n'.

See also `erc-server-send'.

(fn TGT L &optional FORCE)
(defalias 'erc-send-ctcp-notice #[770 "\301!\205\203\302\303\304#!\210\305\303\306#\"\207" [erc-log-p erc-upcase-first-word erc-log-aux format "erc-send-CTCP-notice: [%s] %s" erc-server-send "NOTICE %s :
%s
"] 9 (#$ . 35695)])
#@72 Parse IRCv3 tags list in STRING to a (tag . value) alist.

(fn STRING)
(defalias 'erc-parse-tags #[257 "\300\301\302\"\211\211\203'\211@\301
\303\"\211:\203\211\202\211CB\262\210
A\266\202\202\262
\207" [nil split-string ";" "="] 8 (#$ . 36129)])
#@212 Parse and act upon a complete line from an IRC server.
PROC is the process (connection) from which STRING was received.
PROCs `process-buffer' is `current-buffer' when this function is called.

(fn PROC STRING)
(defalias 'erc-parse-server-response #[514 "\211\302\230?\205v
\303 \304\305\306\307\310!\311\"\312$\216
\305H\313=\205&\314\315\316\317\"#\320\321\322\2051\323!$
\203B\314\316\317\"T\"\202C\211\305H\324=\203R\316\317\"\202S\305\325!>\204b\326\327\330D\"\210\211\331\305=\203o	\202u\314\315#I\266\325!>\204\207\326\327\330D\"\210\211\312\316\332#\316\317#\211\205\241\316\332#\262\314#\266\202I\266\211\203\360

H\324=\204\360\211\316\317#\211\205\311\316\332#\262\314#\266\202\325!>\204\342\326\327\330D\"\210\211\333\333HBI\266\202\256\211\203
\314T\"\325!>\204	
\326\327\330D\"\210\211\333\333HBI\266\325!>\204#
\326\327\330D\"\210\211\334\325!>\2047
\326\327\330D\"\210\333H@I\266\325!>\204M
\326\327\330D\"\210\211\333\325!>\204a
\326\327\330D\"\210\333H\237I\266\335!\210\336\"\266\204)\262
\207" [cl-struct-erc-response-tags erc-session-server "" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 64 substring 1 string-match " " make-erc-response :unparsed :tags erc-parse-tags 58 type-of signal wrong-type-argument erc-response 2 "[^ \n]" 4 5 erc-decode-parsed-server-response erc-handle-parsed-server-response] 16 (#$ . 36394)])
#@279 Decode a pre-parsed PARSED-RESPONSE before it can be handled.

If there is a channel name in `erc-response.command-args', decode
`erc-response' according to this channel name and
`erc-encoding-coding-alist', or use `erc-server-coding-system'
for decoding.

(fn PARSED-RESPONSE)
(defalias 'erc-decode-parsed-server-response #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306\211\211\203,\211@\307\310\"\203%\211\262
A\266\202\202\210
;\2038\311\306\"\262\301!>\204H\302\303\304D\"\210\211\312\311\301!>\204]\302\303\304\nD\"\210\312H\"I\266\301!>\204w\302\303\304D\"\210\211\313\311\301!>\204\214\302\303\304\nD\"\210\313H\"I\266\301!>\204\246\302\303\304D\"\210\211\314\311\301!>\204\273\302\303\304\nD\"\210\314H\"I\266\237\211\203\334\211@\311
\"B\262
A\266\202\202\307\210\301!>\204\355\302\303\304D\"\210\211\305I\266\301!>\204
\302\303\304D\"\210\211\315\311\301!>\204
\302\303\304\nD\"\210\315H\"I\262
\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 nil string-match "^[#&].*" erc-decode-string-from-target 1 2 3 5] 12 (#$ . 37903)])
#@134 Handle a pre-parsed PARSED-RESPONSE from PROCESS.

Hands off to helper functions via `erc-call-hooks'.

(fn PROCESS PARSED-RESPONSE)
(defalias 'erc-handle-parsed-server-response #[514 "\304
!>\204\305\306\307D\"\210\211\310H	\235\203E\304
!>\204&\305\306\307D\"\210\211\311H\312\313\n\"\2062\314\315!\"\203>\316\"\210\317
\320 \n#\207\316\"\207" [cl-struct-erc-response-tags erc-server-prevent-duplicates erc-server-duplicates erc-server-duplicate-timeout type-of signal wrong-type-argument erc-response 3 1 time-less-p gethash 0 time-since erc-call-hooks puthash erc-current-time] 7 (#$ . 39078)])
#@99 Return the hook variable associated with COMMAND.

See also `erc-server-responses'.

(fn COMMAND)
(defalias 'erc-get-hook #[257 "\301\302\247\203\303\202\f\304\"\"\207" [erc-server-responses gethash format "%03i" "%s"] 5 (#$ . 39699)])
#@136 Call hooks associated with MESSAGE in PROCESS.

Finds hooks by looking in the `erc-server-responses' hash table.

(fn PROCESS MESSAGE)
(defalias 'erc-call-hooks #[514 "\301\302!>\204\303\304\305D\"\210
\306H!\206\307\310
#\210\311 \312
!\2050r\211q\210\313\314\315 \")\262
\207" [cl-struct-erc-response-tags erc-get-hook type-of signal wrong-type-argument erc-response 3 erc-default-server-functions run-hook-with-args-until-success erc-server-buffer buffer-live-p run-hook-with-args erc-timer-hook erc-current-time] 7 (#$ . 39948)])
(add-hook 'erc-default-server-functions 'erc-handle-unknown-server-response)
#@62 Display unknown server response's message.

(fn PROC PARSED)
(defalias 'erc-handle-unknown-server-response #[514 "\301
!>\204\302\303\304D\"\210\211\305H\306\301!>\204\"\302\303\304D\"\210\307H\306\310\311\301!>\2049\302\303\304	D\"\210\312H\306#\260\313\314$\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 2 " " 3 mapconcat identity 4 erc-display-message notice] 12 (#$ . 40575)])
(put 'define-erc-response-handler 'edebug-form-spec '(&define :name erc-response-handler (name &rest name) &optional sexp sexp def-body))
#@2909 Define an ERC handler hook/function pair.
NAME is the response name as sent by the server (see the IRC RFC for
meanings).

This creates:
 - a hook variable `erc-server-NAME-functions' initialized to
   `erc-server-NAME'.
 - a function `erc-server-NAME' with body FN-BODY.

If ALIASES is non-nil, each alias in ALIASES is `defalias'ed to
`erc-server-NAME'.
Alias hook variables are created as `erc-server-ALIAS-functions' and
initialized to the same default value as `erc-server-NAME-functions'.

FN-BODY is the body of `erc-server-NAME' it may refer to the two
function arguments PROC and PARSED.

If EXTRA-FN-DOC is non-nil, it is inserted at the beginning of the
defined function's docstring.

If EXTRA-VAR-DOC is non-nil, it is inserted at the beginning of the
defined variable's docstring.

As an example:

  (define-erc-response-handler (311 WHOIS WI)
    "Some non-generic function documentation."
    "Some non-generic variable documentation."
    (do-stuff-with-whois proc parsed))

Would expand to:

  (prog2
      (defvar erc-server-311-functions \='erc-server-311
        "Some non-generic variable documentation.

  Hook called upon receiving a 311 server response.
  Each function is called with two arguments, the process associated
  with the response and the parsed response.
  See also `erc-server-311'.")

      (defun erc-server-311 (proc parsed)
        "Some non-generic function documentation.

  Handler for a 311 server response.
  PROC is the server process which returned the response.
  PARSED is the actual response as an `erc-response' struct.
  If you want to add responses don't modify this function, but rather
  add things to `erc-server-311-functions' instead."
        (do-stuff-with-whois proc parsed))

    (puthash "311" \='erc-server-311-functions erc-server-responses)
    (puthash "WHOIS" \='erc-server-WHOIS-functions erc-server-responses)
    (puthash "WI" \='erc-server-WI-functions erc-server-responses)

    (defalias \='erc-server-WHOIS \='erc-server-311)
    (defvar erc-server-WHOIS-functions \='erc-server-311
      "Some non-generic variable documentation.

  Hook called upon receiving a WHOIS server response.

  Each function is called with two arguments, the process associated
  with the response and the parsed response.  If the function returns
  non-nil, stop processing the hook.  Otherwise, continue.

  See also `erc-server-311'.")

    (defalias \='erc-server-WI \='erc-server-311)
    (defvar erc-server-WI-functions \='erc-server-311
      "Some non-generic variable documentation.

  Hook called upon receiving a WI server response.
  Each function is called with two arguments, the process associated
  with the response and the parsed response.  If the function returns
  non-nil, stop processing the hook.  Otherwise, continue.

  See also `erc-server-311'."))

(fn (NAME &rest ALIASES) &optional EXTRA-FN-DOC EXTRA-VAR-DOC &rest FN-BODY)
(defalias 'define-erc-response-handler '(macro . #[128 "\211\203
\211
A\262\242\202\300\301\302GD\"\211\203!\211
A\262\242\202(\300\301\302GD\"\211A\262\242\211A\262\242\247\203A\303\304\305\"!\262\306\307\"\262\303\304\310\"!\303\304\311\"!\312\313\203`\314P\202a\315#\312\316\203q\314P\202r\315$\317\211:\203\225@\262\303\304\311\"!
B\262
A\262\202{\211\237\266\203\317\211:\203\267@\262\303\304\310\"!
B\262
A\262\202\235\211\237\266\203\320\321\317\304\"F\322\323	D\324	DE\325\326\327BBBBB\330\323\nD\331\323DF\330\323\fD\332\323DF\333B\317\nB\317\211:\2031
@\262:\2031
@\262\334\304\335\"\323D\336BBB
B\262
A\262A\262\202
\211\237\266\205	\317\n\317\317\211:\203\224
@\262:\203\224
@\262:\203\224
@\262\337\323D\323DE\321\323D\304\"F\330\323D\340\323DFE\237
\244\262
A\262A\262A\262\202?
\211\237\266\207\"BBBBBB\266\206\207" [signal wrong-number-of-arguments define-erc-response-handler intern format "%03i" mapcar #[257 "\211\247\203\n\300\301\"\207\207" [format "%03i"] 4 "\n\n(fn A)"] "erc-server-%s-functions" "erc-server-%s" format-message "%sHook called upon receiving a %%s server response.\nEach function is called with two arguments, the process associated\nwith the response and the parsed response.  If the function returns\nnon-nil, stop processing the hook.  Otherwise, continue.\n\nSee also `%s'." "\n\n" "" "%sHandler for a %s server response.\nPROC is the server process which returned the response.\nPARSED is the actual response as an `erc-response' struct.\nIf you want to add responses don't modify this function, but rather\nadd things to `%s' instead." nil prog2 defvar add-hook quote function defun (proc parsed) (ignore proc parsed) put 'definition-name 'definition-name append puthash "%s" (erc-server-responses) defalias 'definition-name] 33 (#$ . 41158)]))
#@275 Hook called upon receiving a ERROR server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-ERROR'.
(defvar erc-server-ERROR-functions nil (#$ . 46000))
(add-hook 'erc-server-ERROR-functions 'erc-server-ERROR)
#@333 Handle an ERROR command from the server.

Handler for a ERROR server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-ERROR-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-ERROR #[514 "\302\303
\304\305\306\307\310!	>\204\311\312\313	D\"\210\314H\315\310	!	>\204/\311\312\313D\"\210\316H&\207" [erc-server-error-occurred cl-struct-erc-response-tags t erc-display-message error nil ERROR 115 type-of signal wrong-type-argument erc-response 2 99 5] 14 (#$ . 46391)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-ERROR definition-name ERROR erc-server-ERROR-functions puthash "ERROR"] 4)
#@277 Hook called upon receiving a INVITE server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-INVITE'.
(defvar erc-server-INVITE-functions nil (#$ . 47246))
(add-hook 'erc-server-INVITE-functions 'erc-server-INVITE)
#@322 Handle invitation messages.

Handler for a INVITE server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-INVITE-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-INVITE #[514 "\302
!>\204\303\304\305D\"\210\211\306H@\302!>\204\"\303\304\305D\"\210
\307H\310\302!>\2046\303\304\305D\"\210\311H!\211@
A\211@
A\211@
A
\n\312 \230\205i\313
\314\315\316\317\320	\321\f\322&\f\266\203\266\207\207" [cl-struct-erc-response-tags erc-invitation type-of signal wrong-type-argument erc-response 4 5 erc-parse-user 2 erc-current-nick erc-display-message notice active INVITE 110 117 104 99] 27 (#$ . 47642)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-INVITE definition-name INVITE erc-server-INVITE-functions puthash "INVITE"] 4)
#@273 Hook called upon receiving a JOIN server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-JOIN'.
(defvar erc-server-JOIN-functions nil (#$ . 48646))
(add-hook 'erc-server-JOIN-functions 'erc-server-JOIN)
#@312 Handle join messages.

Handler for a JOIN server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-JOIN-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-JOIN #[514 "\305
!>\204\306\307\310D\"\210\211\311H\312\313\305!>\204$\306\307\310D\"\210\314H!\211@
A\211@
A\211@
A
\315\316
\"\203G\317\320
\"\262\f\212\321
!\203\276\322	\n\312\211C\f&	\262\n\203u\nq\210\323\f!\210\324\325\326\"!\210\327!\203\203
\202\234\211\206\216\330\f!\205\216\f\205\232\211\205\232\331\"\262
\332
!\203\252r\211q\210\333 \210)\266\334 \210\335\336!\210\337\340\341\342#!\202\327\331\f\"\262\337\340\343\344\345\346\n\342&	!\203\340q\210\347
\211\350\312\211\211\211\211

&\210\351\312$\262
)\266\203\266\207\207" [cl-struct-erc-response-tags erc-session-server erc-session-port erc-session-user-full-name erc-server-process type-of signal wrong-type-argument erc-response 5 nil erc-parse-user 2 string-match "^\\(.*\\).*$" match-string 1 erc-current-nick-p erc-open erc-add-default-channel erc-server-send format "MODE %s" bufferp processp erc-get-buffer buffer-live-p erc-channel-begin-receiving-names erc-update-mode-line run-hooks erc-join-hook erc-make-notice erc-format-message JOIN-you 99 JOIN 110 117 104 erc-update-channel-member t erc-display-message] 27 (#$ . 49032)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-JOIN definition-name JOIN erc-server-JOIN-functions puthash "JOIN"] 4)
#@273 Hook called upon receiving a KICK server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-KICK'.
(defvar erc-server-KICK-functions nil (#$ . 50734))
(add-hook 'erc-server-KICK-functions 'erc-server-KICK)
#@337 Handle kick messages received from the server.

Handler for a KICK server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-KICK-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-KICK #[514 "\302
!>\204\303\304\305D\"\210\211\306H@\302!>\204\"\303\304\305D\"\210
\306HA@\307\302!>\2048\303\304\305D\"\210\310H!\311\"\312\302!>\204S\303\304\305D\"\210\313H!\211@
A\211@
A\211@
A
\314\"\210\f\315 \230\203\331\316\317
\320\321\322	\323\f\324\325&\210\326\327\f\"\210\n\330\331!\203\242
\202\273\211\206\255\332	!\205\255	\205\271\211\205\271\311\"\262
\333
!\203\311r\211q\210\334 \210)\266\335\f\"\210\336!\202
\211\315 \230\203\365\316\317
\337\340\324\325&\n\202
\316\317
\341\340\321\322\323\324\325&\266\203\266\207\207" [cl-struct-erc-response-tags erc-server-process type-of signal wrong-type-argument erc-response 4 erc-trim-string 5 erc-get-buffer erc-parse-user 2 erc-remove-channel-member erc-current-nick erc-display-message notice KICK-you 110 117 104 99 114 run-hook-with-args erc-kick-hook nil bufferp processp buffer-live-p erc-remove-channel-users erc-delete-default-channel erc-update-mode-line KICK-by-you 107 KICK] 33 (#$ . 51120)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-KICK definition-name KICK erc-server-KICK-functions puthash "KICK"] 4)
#@273 Hook called upon receiving a MODE server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-MODE'.
(defvar erc-server-MODE-functions nil (#$ . 52731))
(add-hook 'erc-server-MODE-functions 'erc-server-MODE)
#@318 Handle server mode changes.

Handler for a MODE server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-MODE-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-MODE #[514 "\302
!>\204\303\304\305D\"\210\211\306H@\307\310\302!>\204%\303\304\305D\"\210\306HA\311#\312\302!>\204<\303\304\305D\"\210\313H!\211@
A\211@
A\211@
A
	\203_\314\315\316$!\210\317\f!\203o\320\f\"\202\211\321 \230\203{\322\202\211\323 \203\205\323 \202\211\320\f!r\211\206\217pq\210\324

%\210)\325\230\204\252\325\230\203\277\326\327\330\331\332\333&\n\210\202\327\326\327\334\331\335\n\336
\332\333&\210\210\337\"\266\203\266\207\207" [cl-struct-erc-response-tags erc-log-p type-of signal wrong-type-argument erc-response 4 mapconcat identity " " erc-parse-user 2 erc-log-aux format "MODE: %s -> %s: %s" erc-channel-p erc-get-buffer erc-current-nick nil erc-active-buffer erc-update-modes "" erc-display-message notice MODE-nick 110 116 109 MODE 117 104 erc-banlist-update] 30 (#$ . 53117)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-MODE definition-name MODE erc-server-MODE-functions puthash "MODE"] 4)
#@273 Hook called upon receiving a NICK server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-NICK'.
(defvar erc-server-NICK-functions nil (#$ . 54526))
(add-hook 'erc-server-NICK-functions 'erc-server-NICK)
#@319 Handle nick change messages.

Handler for a NICK server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-NICK-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-NICK #[514 "\305
!>\204\306\307\310D\"\210\211\311H\312C\313\305!>\204%\306\307\310D\"\210\314H!\211@
A\211@
A\211@
A
\n\315\"\240\210	\203O\316\317\320#!\210\321\322\323\324\325\326#\327\"\330$!\210\331

\312\211&\210\211\332 \230\203\272\333 \334

\242\"\204\211

\242B\240\210\210\335\f!\210\336 \210\323:\203\235\202\237C\337
\340
\242\341\342\343&\210\344\345
#\202\334\346\347EC#\210\337
\340
\242\350\342\351	\352\f\343&\f\266\203\266\207\207" [cl-struct-erc-response-tags erc-log-p erc-nick-change-attempt-count erc-nick erc-default-nicks type-of signal wrong-type-argument erc-response 5 nil erc-parse-user 2 erc-buffer-list-with-nick erc-log-aux format "NICK: %s -> %s" erc-buffer-filter make-byte-code 0 "\304 \302\232\205*\300AB\305\300\306\"\210\307 \210p\310
\301\242\"\203\"\301\242\202(\301
\301\242B\240\262
\207" vconcat vector [erc-default-recipients erc-default-target rename-buffer t erc-update-mode-line memql] 4 erc-update-user-nick erc-current-nick erc-server-buffer memql erc-set-current-nick erc-update-mode-line erc-display-message notice NICK-you 110 78 run-hook-with-args erc-nick-changed-functions erc-handle-user-status-change nick NICK 117 104] 27 (#$ . 54912)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-NICK definition-name NICK erc-server-NICK-functions puthash "NICK"] 4)
#@273 Hook called upon receiving a PART server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-PART'.
(defvar erc-server-PART-functions nil (#$ . 56711))
(add-hook 'erc-server-PART-functions 'erc-server-PART)
#@312 Handle part messages.

Handler for a PART server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-PART-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-PART #[514 "\303
!>\204\304\305\306D\"\210\211\307H@\310\303!>\204#\304\305\306D\"\210\311H!\312\"\313\303!>\204<\304\305\306D\"\210\314H!\211@
A\211@
A\211@
A
\315\"\210\316\317
\320\321\322	\323\f\324\325\206p\326&\210\211\327 \230\205\312\330\331\f\"\210\n\332\333!\203\215
\202\246\211\206\230\334	!\205\230	\205\244\211\205\244\312\"\262
\335
!\203\264r\211q\210\336 \210)\266\337
\f\"\210\340!\210\n\205\312\341!\266\203\266\207\207" [cl-struct-erc-response-tags erc-server-process erc-kill-buffer-on-part type-of signal wrong-type-argument erc-response 4 erc-trim-string 5 erc-get-buffer erc-parse-user 2 erc-remove-channel-member erc-display-message notice PART 110 117 104 99 114 "" erc-current-nick run-hook-with-args erc-part-hook nil bufferp processp buffer-live-p erc-remove-channel-users erc-delete-default-channel erc-update-mode-line kill-buffer] 30 (#$ . 57097)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-PART definition-name PART erc-server-PART-functions puthash "PART"] 4)
#@273 Hook called upon receiving a PING server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-PING'.
(defvar erc-server-PING-functions nil (#$ . 58558))
(add-hook 'erc-server-PING-functions 'erc-server-PING)
#@312 Handle ping messages.

Handler for a PING server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-PING-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-PING #[514 "\304
!>\204\305\306\307D\"\210\211\310H@	\203\311\312\313\"!\210\314\312\315\"\316\"\210\n\2038\317\320\321\322\323\324 \"&\210\324 \211\207" [cl-struct-erc-response-tags erc-log-p erc-verbose-server-ping erc-server-last-ping-time type-of signal wrong-type-argument erc-response 4 erc-log-aux format "PING: %s" erc-server-send "PONG :%s" t erc-display-message error PING 115 erc-time-diff erc-current-time] 12 (#$ . 58944)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-PING definition-name PING erc-server-PING-functions puthash "PING"] 4)
#@273 Hook called upon receiving a PONG server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-PONG'.
(defvar erc-server-PONG-functions nil (#$ . 59917))
(add-hook 'erc-server-PONG-functions 'erc-server-PONG)
#@312 Handle pong messages.

Handler for a PONG server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-PONG-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-PONG #[514 "\303\304!>\204\305\306\307D\"\210
\310H!\211\311V\205R\312
\313\"\n\203P\314\315\316\317\304!>\204:\305\306\307\nD\"\210\320H@\321	\322	\323U\204L\324\202M\325&\n\210\326 \207" [cl-struct-erc-response-tags erc-server-lag erc-verbose-server-ping string-to-number type-of signal wrong-type-argument erc-response 5 0 erc-time-diff nil erc-display-message notice PONG 104 4 105 115 1 "s" "" erc-update-mode-line] 15 (#$ . 60303)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-PONG definition-name PONG erc-server-PONG-functions puthash "PONG"] 4)
#@279 Hook called upon receiving a PRIVMSG server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-PRIVMSG'.
(defvar erc-server-PRIVMSG-functions nil (#$ . 61283))
(add-hook 'erc-server-PRIVMSG-functions 'erc-server-PRIVMSG)
#@353 Handle private messages, including messages in channels.

Handler for a PRIVMSG server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-PRIVMSG-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-PRIVMSG #[514 "\306
!>\204\307\310\311D\"\210\211\312H\306!>\204!\307\310\311D\"\210
\313H\306!>\2043\307\310\311D\"\210\314H@\306!>\204G\307\310\311D\"\210\315H\316!\204Y\317
#\203g	\205t
\320\321$\202t
\322!\211@
A@\3128\323\230\324\230\325!\326\211\211\306!>\204\222\307\310\311D\"\210\211\315
I\266\327\203\245	\202\247\f\"\262
\203\344r
q\210\330\203\276	\202\300\f\n\211\326\211\211\211\211\326\211\331&\210\332\333\n!\n\"
@A\"\266\202)\334!\203
\203\376\335%\202
\336\337\340\"&\262\2029
\f	\240\210\341
\206!
	\f\205.
\342!\205.

?\2054
	$\262\203e
\203\\
\203\\
\343\344
%\210\345\346
%\210\202e
\347\326$\210\f\323\230\205r
\350\"\266\212\207" [cl-struct-erc-response-tags erc-minibuffer-ignored erc-channel-users erc-format-nick-function erc-server-last-peers erc-format-query-as-channel-p type-of signal wrong-type-argument erc-response 2 3 4 5 erc-ignored-user-p erc-ignored-reply-p message "Ignored %s from %s to %s" erc-parse-user "PRIVMSG" "NOTICE" erc-current-nick-p nil erc-get-buffer erc-update-channel-member t gethash erc-downcase erc-is-message-ctcp-p erc-process-ctcp-query erc-process-ctcp-reply match-string 1 erc-format-privmessage erc-query-buffer-p run-hook-with-args erc-echo-notice-always-hook run-hook-with-args-until-success erc-echo-notice-hook erc-display-message erc-auto-query] 31 (#$ . 61684)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\210\306\310\311#\210\312\313\302\"\207" [erc-server-responses put erc-server-PRIVMSG definition-name PRIVMSG erc-server-PRIVMSG-functions puthash "PRIVMSG" "NOTICE" erc-server-NOTICE-functions defalias erc-server-NOTICE] 4)
#@278 Hook called upon receiving a NOTICE server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-PRIVMSG'.
(defvar erc-server-NOTICE-functions 'erc-server-PRIVMSG (#$ . 63825))
(byte-code "\300\301\302\303#\210\304\303\305\"\207" [put erc-server-NOTICE-functions definition-name erc-server-PRIVMSG-functions add-hook erc-auto-query] 4)
#@273 Hook called upon receiving a QUIT server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-QUIT'.
(defvar erc-server-QUIT-functions nil (#$ . 64338))
(add-hook 'erc-server-QUIT-functions 'erc-server-QUIT)
#@317 Another user has quit IRC.

Handler for a QUIT server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-QUIT-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-QUIT #[514 "\301
!>\204\302\303\304D\"\210\211\305H\306\307\301!>\204$\302\303\304D\"\210\310H!\211@
A\211@
A\211@
A
\311
\"\262\312
!\210\313\f$\262\f\314
\315
\316\317\320	\321\f\322&\f\266\203\266\207\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 5 nil erc-parse-user 2 erc-buffer-list-with-nick erc-remove-user erc-wash-quit-reason erc-display-message notice QUIT 110 117 104 114] 27 (#$ . 64724)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-QUIT definition-name QUIT erc-server-QUIT-functions puthash "QUIT"] 4)
#@275 Hook called upon receiving a TOPIC server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-TOPIC'.
(defvar erc-server-TOPIC-functions nil (#$ . 65719))
(add-hook 'erc-server-TOPIC-functions 'erc-server-TOPIC)
#@323 The channel topic has changed.

Handler for a TOPIC server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-TOPIC-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-TOPIC #[514 "\302
!>\204\303\304\305D\"\210\211\306H@\307\302!>\204#\303\304\305D\"\210\310H!\311	!\312\302!>\204;\303\304\305D\"\210\313H!\211@
A\211@
A\211@
A
\314
\211\315\211\211\211\211\211\f\f&\210\316
\317\320$\"\210\321\322\323\"\324\325\326	\327\f\330\331&\266\203\266\207\207" [cl-struct-erc-response-tags erc-server-timestamp-format type-of signal wrong-type-argument erc-response 4 erc-trim-string 5 format-time-string erc-parse-user 2 erc-update-channel-member nil erc-update-channel-topic format "%s (%s, %s)" erc-display-message notice erc-get-buffer TOPIC 110 117 104 99 84] 30 (#$ . 66110)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-TOPIC definition-name TOPIC erc-server-TOPIC-functions puthash "TOPIC"] 4)
#@279 Hook called upon receiving a WALLOPS server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-WALLOPS'.
(defvar erc-server-WALLOPS-functions nil (#$ . 67301))
(add-hook 'erc-server-WALLOPS-functions 'erc-server-WALLOPS)
#@323 Display a WALLOPS message.

Handler for a WALLOPS server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-WALLOPS-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-WALLOPS #[514 "\301
!>\204\302\303\304D\"\210\211\305H\306\301!>\204\"\302\303\304D\"\210\307H!\211@
A\211@
A\211@
A
\310\f\311\312\313\314\315&\266\203\266\207\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 5 erc-parse-user 2 erc-display-message notice nil WALLOPS 110 109] 22 (#$ . 67702)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-WALLOPS definition-name WALLOPS erc-server-WALLOPS-functions puthash "WALLOPS"] 4)
#@271 Hook called upon receiving a 001 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-001'.
(defvar erc-server-001-functions nil (#$ . 68593))
(add-hook 'erc-server-001-functions 'erc-server-001)
#@378 Set `erc-server-current-nick' to reflect server settings and display the welcome message.

Handler for a 001 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-001-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-001 #[514 "\304\305!>\204\306\307\310D\"\210
\311H@!\210\312 \210\313\n:\203$\n\202&\nC\314
\315\316\305!>\204;\306\307\310D\"\210\317H$\207" [cl-struct-erc-response-tags erc-nick-change-attempt-count erc-nick erc-default-nicks erc-set-current-nick type-of signal wrong-type-argument erc-response 4 erc-update-mode-line 0 erc-display-message notice active 5] 10 (#$ . 68974)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-001 definition-name \001 erc-server-001-functions puthash "001"] 4)
#@273 Hook called upon receiving a MOTD server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-MOTD'.
(defvar erc-server-MOTD-functions nil (#$ . 69951))
(add-hook 'erc-server-MOTD-functions 'erc-server-MOTD)
#@331 Display the server's message of the day.

Handler for a MOTD server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-MOTD-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-MOTD #[514 "\302 \210\303
\304\203\305\202\306!	>\204\307\310\311D\"\210\312H$\207" [erc-server-connected cl-struct-erc-response-tags erc-handle-login erc-display-message notice active type-of signal wrong-type-argument erc-response 5] 10 (#$ . 70337)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\210\306\310\311#\210\306\312\313#\210\306\314\315#\210\306\316\317#\210\306\320\321#\210\306\322\323#\210\324\325\302\"\207" [erc-server-responses put erc-server-MOTD definition-name MOTD erc-server-MOTD-functions puthash "MOTD" "002" erc-server-002-functions "003" erc-server-003-functions "371" erc-server-371-functions "372" erc-server-372-functions "374" erc-server-374-functions "375" erc-server-375-functions defalias erc-server-002] 4)
#@272 Hook called upon receiving a 002 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-MOTD'.
(defvar erc-server-002-functions 'erc-server-MOTD (#$ . 71480))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-002-functions definition-name erc-server-MOTD-functions defalias erc-server-003 erc-server-MOTD] 4)
#@272 Hook called upon receiving a 003 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-MOTD'.
(defvar erc-server-003-functions 'erc-server-MOTD (#$ . 71991))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-003-functions definition-name erc-server-MOTD-functions defalias erc-server-371 erc-server-MOTD] 4)
#@272 Hook called upon receiving a 371 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-MOTD'.
(defvar erc-server-371-functions 'erc-server-MOTD (#$ . 72502))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-371-functions definition-name erc-server-MOTD-functions defalias erc-server-372 erc-server-MOTD] 4)
#@272 Hook called upon receiving a 372 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-MOTD'.
(defvar erc-server-372-functions 'erc-server-MOTD (#$ . 73013))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-372-functions definition-name erc-server-MOTD-functions defalias erc-server-374 erc-server-MOTD] 4)
#@272 Hook called upon receiving a 374 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-MOTD'.
(defvar erc-server-374-functions 'erc-server-MOTD (#$ . 73524))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-374-functions definition-name erc-server-MOTD-functions defalias erc-server-375 erc-server-MOTD] 4)
#@272 Hook called upon receiving a 375 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-MOTD'.
(defvar erc-server-375-functions 'erc-server-MOTD (#$ . 74035))
(put 'erc-server-375-functions 'definition-name 'erc-server-MOTD-functions)
#@271 Hook called upon receiving a 376 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-376'.
(defvar erc-server-376-functions nil (#$ . 74453))
(add-hook 'erc-server-376-functions 'erc-server-376)
#@317 End of MOTD/MOTD is missing.

Handler for a 376 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-376-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-376 #[514 "\300\"\210\301\"\207" [erc-server-MOTD erc-connection-established] 5 (#$ . 74834)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\210\306\310\311#\210\312\313\302\"\207" [erc-server-responses put erc-server-376 definition-name \376 erc-server-376-functions puthash "376" "422" erc-server-422-functions defalias erc-server-422] 4)
#@271 Hook called upon receiving a 422 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-376'.
(defvar erc-server-422-functions 'erc-server-376 (#$ . 75548))
(put 'erc-server-422-functions 'definition-name 'erc-server-376-functions)
#@271 Hook called upon receiving a 004 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-004'.
(defvar erc-server-004-functions nil (#$ . 75963))
(add-hook 'erc-server-004-functions 'erc-server-004)
#@325 Display the server's identification.

Handler for a 004 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-004-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-004 #[514 "\303
!>\204\304\305\306D\"\210\211\307HA\211@
A\211@
A

\211\310\311\n!!\210\312\313\314\315\316	\317\320\303!>\204H\304\305\306D\"\210\307H8\321\307\303!>\204`\304\305\306D\"\210\307H8&\f\266\202\207" [cl-struct-erc-response-tags erc-server-version erc-server-announced-name type-of signal wrong-type-argument erc-response 4 erc-update-mode-line-buffer process-buffer erc-display-message notice s004 115 118 85 3 67] 26 (#$ . 76344)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-004 definition-name \004 erc-server-004-functions puthash "004"] 4)
#@271 Hook called upon receiving a 005 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-005'.
(defvar erc-server-005-functions nil (#$ . 77354))
(add-hook 'erc-server-005-functions 'erc-server-005)
#@760 Set the variable `erc-server-parameters' and display the received message.

According to RFC 2812, suggests alternate servers on the network.
Many servers, however, use this code to show which parameters they have set,
for example, the network identifier, maximum allowed topic length, whether
certain commands are accepted and more.  See documentation for
`erc-server-parameters' for more information on the parameters sent.

A server may send more than one 005 message.

Handler for a 005 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-005-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-005 #[514 "\301\302\303!>\204\304\305\306D\"\210\211\307\303!>\204%\304\305\306D\"\210\307HAI\262
\310#\303!>\204=\304\305\306D\"\210
\307H\203\303!>\204R\304\305\306D\"\210
\211\307H\211\307AI\210\266\202\242\311\312\"\203{\313\314\315\316\"\206t\315\317\"\315\320\"B\"\210\210\202.\321\322$\207" [cl-struct-erc-response-tags mapconcat identity type-of signal wrong-type-argument erc-response 4 " " string-match "^\\([A-Z]+\\)=\\(.*\\)$\\|^\\([A-Z]+\\)$" add-to-list erc-server-parameters match-string 1 3 2 erc-display-message notice] 11 (#$ . 77735)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-005 definition-name \005 erc-server-005-functions puthash "005"] 4)
#@271 Hook called upon receiving a 221 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-221'.
(defvar erc-server-221-functions nil (#$ . 79292))
(add-hook 'erc-server-221-functions 'erc-server-221)
#@320 Display the current user modes.

Handler for a 221 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-221-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-221 #[514 "\301
!>\204\302\303\304D\"\210\211\305H@\306\307\301!>\204%\302\303\304D\"\210\305HA\310#\311\"\210\312\313\314\315\316\317&\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 mapconcat identity " " erc-set-modes erc-display-message notice active s221 110 109] 13 (#$ . 79673)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-221 definition-name \221 erc-server-221-functions puthash "221"] 4)
#@271 Hook called upon receiving a 252 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-252'.
(defvar erc-server-252-functions nil (#$ . 80541))
(add-hook 'erc-server-252-functions 'erc-server-252)
#@332 Display the number of IRC operators online.

Handler for a 252 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-252-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-252 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message notice active s252 105 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 80922)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-252 definition-name \252 erc-server-252-functions puthash "252"] 4)
#@271 Hook called upon receiving a 253 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-253'.
(defvar erc-server-253-functions nil (#$ . 81687))
(add-hook 'erc-server-253-functions 'erc-server-253)
#@331 Display the number of unknown connections.

Handler for a 253 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-253-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-253 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message notice active s253 105 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 82068)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-253 definition-name \253 erc-server-253-functions puthash "253"] 4)
#@271 Hook called upon receiving a 254 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-254'.
(defvar erc-server-254-functions nil (#$ . 82832))
(add-hook 'erc-server-254-functions 'erc-server-254)
#@327 Display the number of channels formed.

Handler for a 254 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-254-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-254 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message notice active s254 105 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 83213)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-254 definition-name \254 erc-server-254-functions puthash "254"] 4)
#@271 Hook called upon receiving a 250 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-250-functions nil (#$ . 83973))
(add-hook 'erc-server-250-functions 'erc-server-250)
#@370 Generic display of server messages as notices.

See `erc-display-server-message'.

Handler for a 250 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-250-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-250 #[514 "\300\"\207" [erc-display-server-message] 5 (#$ . 84354)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\210\306\310\311#\210\306\312\313#\210\306\314\315#\210\306\316\317#\210\306\320\321#\210\306\322\323#\210\306\324\325#\210\306\326\327#\210\306\330\331#\210\306\332\333#\210\334\335\302\"\207" [erc-server-responses put erc-server-250 definition-name \250 erc-server-250-functions puthash "250" "251" erc-server-251-functions "255" erc-server-255-functions "256" erc-server-256-functions "257" erc-server-257-functions "258" erc-server-258-functions "259" erc-server-259-functions "265" erc-server-265-functions "266" erc-server-266-functions "377" erc-server-377-functions "378" erc-server-378-functions defalias erc-server-251] 4)
#@271 Hook called upon receiving a 251 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-251-functions 'erc-server-250 (#$ . 85534))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-251-functions definition-name erc-server-250-functions defalias erc-server-255 erc-server-250] 4)
#@271 Hook called upon receiving a 255 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-255-functions 'erc-server-250 (#$ . 86041))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-255-functions definition-name erc-server-250-functions defalias erc-server-256 erc-server-250] 4)
#@271 Hook called upon receiving a 256 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-256-functions 'erc-server-250 (#$ . 86548))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-256-functions definition-name erc-server-250-functions defalias erc-server-257 erc-server-250] 4)
#@271 Hook called upon receiving a 257 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-257-functions 'erc-server-250 (#$ . 87055))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-257-functions definition-name erc-server-250-functions defalias erc-server-258 erc-server-250] 4)
#@271 Hook called upon receiving a 258 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-258-functions 'erc-server-250 (#$ . 87562))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-258-functions definition-name erc-server-250-functions defalias erc-server-259 erc-server-250] 4)
#@271 Hook called upon receiving a 259 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-259-functions 'erc-server-250 (#$ . 88069))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-259-functions definition-name erc-server-250-functions defalias erc-server-265 erc-server-250] 4)
#@271 Hook called upon receiving a 265 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-265-functions 'erc-server-250 (#$ . 88576))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-265-functions definition-name erc-server-250-functions defalias erc-server-266 erc-server-250] 4)
#@271 Hook called upon receiving a 266 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-266-functions 'erc-server-250 (#$ . 89083))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-266-functions definition-name erc-server-250-functions defalias erc-server-377 erc-server-250] 4)
#@271 Hook called upon receiving a 377 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-377-functions 'erc-server-250 (#$ . 89590))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-377-functions definition-name erc-server-250-functions defalias erc-server-378 erc-server-250] 4)
#@271 Hook called upon receiving a 378 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-250'.
(defvar erc-server-378-functions 'erc-server-250 (#$ . 90097))
(put 'erc-server-378-functions 'definition-name 'erc-server-250-functions)
#@271 Hook called upon receiving a 275 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-275'.
(defvar erc-server-275-functions nil (#$ . 90512))
(add-hook 'erc-server-275-functions 'erc-server-275)
#@323 Display secure connection message.

Handler for a 275 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-275-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-275 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA\211@
A\211@
A\211@
A
\306\307\310\311\312\313\314\315\301!>\204@\302\303\304D\"\210\305HAA\316#&\266\203\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-display-message notice active s275 110 109 mapconcat identity " "] 26 (#$ . 90893)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-275 definition-name \275 erc-server-275-functions puthash "275"] 4)
#@271 Hook called upon receiving a 290 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-290'.
(defvar erc-server-290-functions nil (#$ . 91773))
(add-hook 'erc-server-290-functions 'erc-server-290)
#@323 Handle dancer-ircd CAPAB messages.

Handler for a 290 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-290-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-290 #[514 "\300\207" [nil] 3 (#$ . 92154)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-290 definition-name \290 erc-server-290-functions puthash "290"] 4)
#@271 Hook called upon receiving a 301 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-301'.
(defvar erc-server-301-functions nil (#$ . 92728))
(add-hook 'erc-server-301-functions 'erc-server-301)
#@301 AWAY notice.

Handler for a 301 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-301-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-301 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@\313\306	!>\204/\307\310\311D\"\210\314H&\207" [cl-struct-erc-response-tags erc-display-message notice active s301 110 type-of signal wrong-type-argument erc-response 4 114 5] 14 (#$ . 93109)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-301 definition-name \301 erc-server-301-functions puthash "301"] 4)
#@271 Hook called upon receiving a 303 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-303'.
(defvar erc-server-303-functions nil (#$ . 93896))
(add-hook 'erc-server-303-functions 'erc-server-303)
#@299 ISON reply

Handler for a 303 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-303-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-303 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message notice active s303 110 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 94277)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-303 definition-name \303 erc-server-303-functions puthash "303"] 4)
#@271 Hook called upon receiving a 305 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-305'.
(defvar erc-server-305-functions nil (#$ . 95009))
(add-hook 'erc-server-305-functions 'erc-server-305)
#@310 Return from AWAYness.

Handler for a 305 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-305-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-305 #[514 "\301\302\"\210\303
\304\305\306\307\310!>\204\311\312\313	D\"\210\314H&\207" [cl-struct-erc-response-tags erc-process-away nil erc-display-message notice active s305 109 type-of signal wrong-type-argument erc-response 5] 12 (#$ . 95390)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-305 definition-name \305 erc-server-305-functions puthash "305"] 4)
#@271 Hook called upon receiving a 306 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-306'.
(defvar erc-server-306-functions nil (#$ . 96167))
(add-hook 'erc-server-306-functions 'erc-server-306)
#@302 Set AWAYness.

Handler for a 306 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-306-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-306 #[514 "\301\302\"\210\303
\304\305\306\307\310!>\204\311\312\313	D\"\210\314H&\207" [cl-struct-erc-response-tags erc-process-away t erc-display-message notice active s306 109 type-of signal wrong-type-argument erc-response 5] 12 (#$ . 96548)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-306 definition-name \306 erc-server-306-functions puthash "306"] 4)
#@271 Hook called upon receiving a 307 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-307'.
(defvar erc-server-307-functions nil (#$ . 97315))
(add-hook 'erc-server-307-functions 'erc-server-307)
#@321 Display nick-identified message.

Handler for a 307 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-307-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-307 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA\211@
A\211@
A\211@
A
\306\307\310\311\312\313\314\315\301!>\204@\302\303\304D\"\210\305HAA\316#&\266\203\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-display-message notice active s307 110 109 mapconcat identity " "] 26 (#$ . 97696)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-307 definition-name \307 erc-server-307-functions puthash "307"] 4)
#@271 Hook called upon receiving a 311 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-311'.
(defvar erc-server-311-functions nil (#$ . 98574))
(add-hook 'erc-server-311-functions 'erc-server-311)
#@310 WHOIS/WHOWAS notices.

Handler for a 311 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-311-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-311 #[514 "\301
!>\204\302\303\304D\"\210\211\305H\306\307\310\301!>\204%\302\303\304D\"\210\311H\"!\301!>\2049\302\303\304D\"\210\312HA\211@
A\211@
A\211@
A
\313
\211\314&\210\315
\316\317\320\321\322\323&\f\266\203\266\207\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 5 intern format "s%s" 3 4 erc-update-user-nick nil erc-display-message notice active 110 102 117 104] 27 (#$ . 98955)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\210\306\310\311#\210\312\313\302\"\207" [erc-server-responses put erc-server-311 definition-name \311 erc-server-311-functions puthash "311" "314" erc-server-314-functions defalias erc-server-314] 4)
#@271 Hook called upon receiving a 314 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-311'.
(defvar erc-server-314-functions 'erc-server-311 (#$ . 100025))
(put 'erc-server-314-functions 'definition-name 'erc-server-311-functions)
#@271 Hook called upon receiving a 312 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-312'.
(defvar erc-server-312-functions nil (#$ . 100441))
(add-hook 'erc-server-312-functions 'erc-server-312)
#@319 Server name response in WHOIS.

Handler for a 312 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-312-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-312 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA\211@
A\211@
A
\306\307\310\311\312\313	\314\301!>\204;\302\303\304D\"\210\315H&\n\266\202\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-display-message notice active s312 110 115 99 5] 23 (#$ . 100823)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-312 definition-name \312 erc-server-312-functions puthash "312"] 4)
#@271 Hook called upon receiving a 313 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-313'.
(defvar erc-server-313-functions nil (#$ . 101665))
(add-hook 'erc-server-313-functions 'erc-server-313)
#@320 IRC Operator response in WHOIS.

Handler for a 313 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-313-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-313 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message notice active s313 110 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 102047)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-313 definition-name \313 erc-server-313-functions puthash "313"] 4)
#@271 Hook called upon receiving a 315 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-315'.
(defvar erc-server-315-functions nil (#$ . 102801))
(add-hook 'erc-server-315-functions 'erc-server-315)
#@326 End of WHO/WHOIS/LIST/WHOWAS notices.

Handler for a 315 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-315-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-315 #[514 "\300\207" [nil] 4 (#$ . 103183)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\210\306\310\311#\210\306\312\313#\210\306\314\315#\210\316\317\302\"\207" [erc-server-responses put erc-server-315 definition-name \315 erc-server-315-functions puthash "315" "318" erc-server-318-functions "323" erc-server-323-functions "369" erc-server-369-functions defalias erc-server-318] 4)
#@271 Hook called upon receiving a 318 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-315'.
(defvar erc-server-318-functions 'erc-server-315 (#$ . 103950))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-318-functions definition-name erc-server-315-functions defalias erc-server-323 erc-server-315] 4)
#@271 Hook called upon receiving a 323 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-315'.
(defvar erc-server-323-functions 'erc-server-315 (#$ . 104458))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-323-functions definition-name erc-server-315-functions defalias erc-server-369 erc-server-315] 4)
#@271 Hook called upon receiving a 369 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-315'.
(defvar erc-server-369-functions 'erc-server-315 (#$ . 104966))
(put 'erc-server-369-functions 'definition-name 'erc-server-315-functions)
#@271 Hook called upon receiving a 317 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-317'.
(defvar erc-server-317-functions nil (#$ . 105382))
(add-hook 'erc-server-317-functions 'erc-server-317)
#@301 IDLE notice.

Handler for a 317 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-317-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-317 #[514 "\302
!>\204\303\304\305D\"\210\211\306HA\211@
A\211@
A\211@
A\211@
A
\n\2053\307	\310!\"\262\311
\211\312\211\211	\205E\313\314\"&\210\203d\315\316\317\320\321\322\323\310!!\324
&\n\202v\315\316\317\325\321\322\323\310!!&\266\204\207" [cl-struct-erc-response-tags erc-server-timestamp-format type-of signal wrong-type-argument erc-response 4 format-time-string string-to-number erc-update-user-nick nil format "on since %s" erc-display-message notice active s317-on-since 110 105 erc-sec-to-time 116 s317] 26 (#$ . 105764)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-317 definition-name \317 erc-server-317-functions puthash "317"] 4)
#@271 Hook called upon receiving a 319 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-319'.
(defvar erc-server-319-functions nil (#$ . 106842))
(add-hook 'erc-server-319-functions 'erc-server-319)
#@321 Channel names in WHOIS response.

Handler for a 319 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-319-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-319 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@\313\306	!>\204/\307\310\311D\"\210\314H&\207" [cl-struct-erc-response-tags erc-display-message notice active s319 110 type-of signal wrong-type-argument erc-response 4 99 5] 14 (#$ . 107224)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-319 definition-name \319 erc-server-319-functions puthash "319"] 4)
#@271 Hook called upon receiving a 320 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-320'.
(defvar erc-server-320-functions nil (#$ . 108031))
(add-hook 'erc-server-320-functions 'erc-server-320)
#@314 Identified user in WHOIS.

Handler for a 320 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-320-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-320 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message notice active s320 110 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 108413)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-320 definition-name \320 erc-server-320-functions puthash "320"] 4)
#@271 Hook called upon receiving a 321 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-321'.
(defvar erc-server-321-functions nil (#$ . 109161))
(add-hook 'erc-server-321-functions 'erc-server-321)
#@301 LIST header.

Handler for a 321 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-321-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-321 #[514 "\301\211\207" [erc-channel-list nil] 4 (#$ . 109543)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-321 definition-name \321 erc-server-321-functions puthash "321"] 4)
#@56 Display a message for the 321 event.

(fn PROC PARSED)
(defalias 'erc-server-321-message #[514 "\300
\301\302$\210\303\207" [erc-display-message notice s321 nil] 7 (#$ . 110117)])
(add-hook 'erc-server-321-functions 'erc-server-321-message t)
#@271 Hook called upon receiving a 322 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-322'.
(defvar erc-server-322-functions nil (#$ . 110368))
(add-hook 'erc-server-322-functions 'erc-server-322)
#@301 LIST notice.

Handler for a 322 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-322-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-322 #[514 "\301
!>\204\302\303\304D\"\210\211\305H\301!>\204!\302\303\304D\"\210
\306HA\211@
A\211@
A
\307\310C\"\210\311
	\"\266\202\266\205\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 5 4 add-to-list erc-channel-list erc-update-channel-topic] 13 (#$ . 110750)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-322 definition-name \322 erc-server-322-functions puthash "322"] 4)
#@56 Display a message for the 322 event.

(fn PROC PARSED)
(defalias 'erc-server-322-message #[514 "\301
!>\204\302\303\304D\"\210\211\305H\301!>\204!\302\303\304D\"\210
\306HA\211@
A\211@
A
\307	\310\f\311\312\313	\314\206C\315&\n\266\202\266\205\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 5 4 erc-display-message notice s322 99 117 116 ""] 21 (#$ . 111570)])
(add-hook 'erc-server-322-functions 'erc-server-322-message t)
#@271 Hook called upon receiving a 324 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-324'.
(defvar erc-server-324-functions nil (#$ . 112053))
(add-hook 'erc-server-324-functions 'erc-server-324)
#@311 Channel or nick modes.

Handler for a 324 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-324-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-324 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\306\307\301!>\204&\302\303\304D\"\210\305HAA\310#\311\"\210\312\313\314\"\315\316\317&\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 mapconcat identity " " erc-set-modes erc-display-message notice erc-get-buffer s324 99 109] 13 (#$ . 112435)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-324 definition-name \324 erc-server-324-functions puthash "324"] 4)
#@271 Hook called upon receiving a 328 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-328'.
(defvar erc-server-328-functions nil (#$ . 113309))
(add-hook 'erc-server-328-functions 'erc-server-328)
#@323 Channel URL (on freenode network).

Handler for a 328 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-328-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-328 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\301!>\204#\302\303\304D\"\210
\306H\307\310\311\"\312\313\314&\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 5 erc-display-message notice erc-get-buffer s328 99 117] 13 (#$ . 113691)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-328 definition-name \328 erc-server-328-functions puthash "328"] 4)
#@271 Hook called upon receiving a 329 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-329'.
(defvar erc-server-329-functions nil (#$ . 114514))
(add-hook 'erc-server-329-functions 'erc-server-329)
#@311 Channel creation date.

Handler for a 329 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-329-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-329 #[514 "\302
!>\204\303\304\305D\"\210\211\306HA@\307\310\302!>\204&\303\304\305D\"\210\306H8!\311\312\313\"\314\315\316\317	\n\"&\207" [cl-struct-erc-response-tags erc-server-timestamp-format type-of signal wrong-type-argument erc-response 4 string-to-number 2 erc-display-message notice erc-get-buffer s329 99 116 format-time-string] 15 (#$ . 114896)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-329 definition-name \329 erc-server-329-functions puthash "329"] 4)
#@271 Hook called upon receiving a 330 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-330'.
(defvar erc-server-330-functions nil (#$ . 115790))
(add-hook 'erc-server-330-functions 'erc-server-330)
#@329 Nick is authed as (on Quakenet network).

Handler for a 330 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-330-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-330 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\306\301!>\204$\302\303\304D\"\210\305H8\301!>\2047\302\303\304D\"\210\307H\310\311\312\313\314\315\316&\n\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 2 5 erc-display-message notice active s330 110 97 105] 16 (#$ . 116172)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-330 definition-name \330 erc-server-330-functions puthash "330"] 4)
#@271 Hook called upon receiving a 331 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-331'.
(defvar erc-server-331-functions nil (#$ . 117046))
(add-hook 'erc-server-331-functions 'erc-server-331)
#@314 No topic set for channel.

Handler for a 331 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-331-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-331 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\306\307\310\"\311\312&\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-display-message notice erc-get-buffer s331 99] 10 (#$ . 117428)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-331 definition-name \331 erc-server-331-functions puthash "331"] 4)
#@271 Hook called upon receiving a 332 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-332'.
(defvar erc-server-332-functions nil (#$ . 118190))
(add-hook 'erc-server-332-functions 'erc-server-332)
#@302 TOPIC notice.

Handler for a 332 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-332-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-332 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\301!>\204#\302\303\304D\"\210
\306H\307\"\210\310\311\312\"\313\314\315&\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 5 erc-update-channel-topic erc-display-message notice erc-get-buffer s332 99 84] 13 (#$ . 118572)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-332 definition-name \332 erc-server-332-functions puthash "332"] 4)
#@271 Hook called upon receiving a 333 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-333'.
(defvar erc-server-333-functions nil (#$ . 119410))
(add-hook 'erc-server-333-functions 'erc-server-333)
#@317 Who set the topic, and when.

Handler for a 333 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-333-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-333 #[514 "\302
!>\204\303\304\305D\"\210\211\306HA\211@
A\211@
A\211@
A
\307	\310!\"\262\311
\312\313#\314#\210\315\316\317\"\320\321\322	\323\f&\n\266\203\207" [cl-struct-erc-response-tags erc-server-timestamp-format type-of signal wrong-type-argument erc-response 4 format-time-string string-to-number erc-update-channel-topic format " (%s, %s)" append erc-display-message notice erc-get-buffer s333 99 110 116] 23 (#$ . 119792)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-333 definition-name \333 erc-server-333-functions puthash "333"] 4)
#@271 Hook called upon receiving a 341 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-341'.
(defvar erc-server-341-functions nil (#$ . 120772))
(add-hook 'erc-server-341-functions 'erc-server-341)
#@353 Let user know when an INVITE attempt has been sent successfully.

Handler for a 341 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-341-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-341 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA\211@
A\211@
A
\306\307\310
\"\311\312\313	&\266\202\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-display-message notice erc-get-buffer s341 110 99] 18 (#$ . 121154)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-341 definition-name \341 erc-server-341-functions puthash "341"] 4)
#@271 Hook called upon receiving a 352 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-352'.
(defvar erc-server-352-functions nil (#$ . 121989))
(add-hook 'erc-server-352-functions 'erc-server-352)
#@300 WHO notice.

Handler for a 352 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-352-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-352 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA\211@
A\211@
A\211@
A\211@
A\211@
A\211@
A
\n
\301!>\204F\302\303\304D\"\210\306H\307\310\"\203W\311\312\"\262
\313\211\314\211\211\211\211\211

\f&\f\210\315\316\317\320\321\322
\323\324\325\326&\262
\266\206\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 5 string-match "\\(^[0-9]+ \\)\\(.*\\)$" match-string 2 erc-update-channel-member nil erc-display-message notice active s352 99 110 97 117 104 102] 39 (#$ . 122371)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-352 definition-name \352 erc-server-352-functions puthash "352"] 4)
#@271 Hook called upon receiving a 353 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-353'.
(defvar erc-server-353-functions nil (#$ . 123432))
(add-hook 'erc-server-353-functions 'erc-server-353)
#@302 NAMES notice.

Handler for a 353 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-353-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-353 #[514 "\302\303!>\204\304\305\306D\"\210
\307H8\303!>\204#\304\305\306D\"\210
\310H\311\312\313\"\2062\314\315\316\317&\210
\320!\203H
\202a\211\206S\321	!\205S	\205_\211\205_\313\"\262
\322
!\205or\211q\210\323!)\266\203\207" [cl-struct-erc-response-tags erc-server-process 2 type-of signal wrong-type-argument erc-response 4 5 erc-display-message notice erc-get-buffer active s353 99 117 bufferp processp buffer-live-p erc-channel-receive-names] 13 (#$ . 123814)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-353 definition-name \353 erc-server-353-functions puthash "353"] 4)
#@271 Hook called upon receiving a 366 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-366'.
(defvar erc-server-366-functions nil (#$ . 124826))
(add-hook 'erc-server-366-functions 'erc-server-366)
#@302 End of NAMES.

Handler for a 366 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-366-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-366 #[514 "\302
!>\204\303\304\305D\"\210\211\306HA@\307!\203
\2028\211\206*\310	!\205*	\2056\211\2056\311\"\262
\312
!\205Er\211q\210\313 )\207" [cl-struct-erc-response-tags erc-server-process type-of signal wrong-type-argument erc-response 4 bufferp processp erc-get-buffer buffer-live-p erc-channel-end-receiving-names] 8 (#$ . 125208)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-366 definition-name \366 erc-server-366-functions puthash "366"] 4)
#@271 Hook called upon receiving a 367 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-367'.
(defvar erc-server-367-functions nil (#$ . 126075))
(add-hook 'erc-server-367-functions 'erc-server-367)
#@314 Channel ban list entries.

Handler for a 367 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-367-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-367 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA\211@
A\211@
A\211@
A\211@
A
\n\203H\306\307\310\311\312\313	\314\f\315\206C\316&\f\202V\306\307\310\317\312\313	&\266\204\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-display-message notice active s367-set-by 99 98 115 116 "" s367] 28 (#$ . 126457)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-367 definition-name \367 erc-server-367-functions puthash "367"] 4)
#@271 Hook called upon receiving a 368 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-368'.
(defvar erc-server-368-functions nil (#$ . 127350))
(add-hook 'erc-server-368-functions 'erc-server-368)
#@313 End of channel ban list.

Handler for a 368 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-368-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-368 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\306\307\310\311\312&\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-display-message notice active s368 99] 10 (#$ . 127732)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-368 definition-name \368 erc-server-368-functions puthash "368"] 4)
#@271 Hook called upon receiving a 379 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-379'.
(defvar erc-server-379-functions nil (#$ . 128480))
(add-hook 'erc-server-379-functions 'erc-server-379)
#@319 Forwarding to another channel.

Handler for a 379 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-379-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-379 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA\211@
A\211@
A
\306\307\310\311\312\313	&\266\202\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-display-message notice active s379 99 102] 18 (#$ . 128862)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-379 definition-name \379 erc-server-379-functions puthash "379"] 4)
#@271 Hook called upon receiving a 391 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-391'.
(defvar erc-server-391-functions nil (#$ . 129650))
(add-hook 'erc-server-391-functions 'erc-server-391)
#@310 Server's time string.

Handler for a 391 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-391-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-391 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@\313\314\306\n!>\2040\307\310\311\fD\"\210	\312H8&\207" [cl-struct-erc-response-tags erc-display-message notice active s391 115 type-of signal wrong-type-argument erc-response 4 116 2] 15 (#$ . 130032)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-391 definition-name \391 erc-server-391-functions puthash "391"] 4)
#@271 Hook called upon receiving a 401 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-401'.
(defvar erc-server-401-functions nil (#$ . 130836))
(add-hook 'erc-server-401-functions 'erc-server-401)
#@310 No such nick/channel.

Handler for a 401 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-401-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-401 #[514 "\303
!>\204\304\305\306D\"\210\211\307HA@	\203*\n\203#\310\311\312\"!\210\313\311\314\"!\210\315\316\317\320\321&\207" [cl-struct-erc-response-tags erc-whowas-on-nosuchnick erc-log-p type-of signal wrong-type-argument erc-response 4 erc-log-aux format "cmd: WHOWAS: %s" erc-server-send "WHOWAS %s 1" erc-display-message (notice error) active s401 110] 10 (#$ . 131218)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-401 definition-name \401 erc-server-401-functions puthash "401"] 4)
#@271 Hook called upon receiving a 403 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-403'.
(defvar erc-server-403-functions nil (#$ . 132129))
(add-hook 'erc-server-403-functions 'erc-server-403)
#@305 No such channel.

Handler for a 403 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-403-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-403 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message (notice error) active s403 99 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 132511)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-403 definition-name \403 erc-server-403-functions puthash "403"] 4)
#@271 Hook called upon receiving a 404 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-404'.
(defvar erc-server-404-functions nil (#$ . 133257))
(add-hook 'erc-server-404-functions 'erc-server-404)
#@312 Cannot send to channel.

Handler for a 404 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-404-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-404 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message (notice error) active s404 99 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 133639)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-404 definition-name \404 erc-server-404-functions puthash "404"] 4)
#@271 Hook called upon receiving a 405 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-405'.
(defvar erc-server-405-functions nil (#$ . 134392))
(add-hook 'erc-server-405-functions 'erc-server-405)
#@319 Can't join that many channels.

Handler for a 405 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-405-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-405 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message (notice error) active s405 99 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 134774)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-405 definition-name \405 erc-server-405-functions puthash "405"] 4)
#@271 Hook called upon receiving a 406 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-406'.
(defvar erc-server-406-functions nil (#$ . 135534))
(add-hook 'erc-server-406-functions 'erc-server-406)
#@302 No such nick.

Handler for a 406 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-406-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-406 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message (notice error) active s406 110 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 135916)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-406 definition-name \406 erc-server-406-functions puthash "406"] 4)
#@271 Hook called upon receiving a 412 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-412'.
(defvar erc-server-412-functions nil (#$ . 136660))
(add-hook 'erc-server-412-functions 'erc-server-412)
#@305 No text to send.

Handler for a 412 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-412-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-412 #[514 "\300
\301\302\303$\207" [erc-display-message (notice error) active s412] 7 (#$ . 137042)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-412 definition-name \412 erc-server-412-functions puthash "412"] 4)
#@271 Hook called upon receiving a 421 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-421'.
(defvar erc-server-421-functions nil (#$ . 137656))
(add-hook 'erc-server-421-functions 'erc-server-421)
#@305 Unknown command.

Handler for a 421 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-421-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-421 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message (notice error) active s421 99 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 138038)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-421 definition-name \421 erc-server-421-functions puthash "421"] 4)
#@271 Hook called upon receiving a 432 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-432'.
(defvar erc-server-432-functions nil (#$ . 138784))
(add-hook 'erc-server-432-functions 'erc-server-432)
#@298 Bad nick.

Handler for a 432 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-432-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-432 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message (notice error) active s432 110 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 139166)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-432 definition-name \432 erc-server-432-functions puthash "432"] 4)
#@271 Hook called upon receiving a 433 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-433'.
(defvar erc-server-433-functions nil (#$ . 139906))
(add-hook 'erc-server-433-functions 'erc-server-433)
#@314 Login-time "nick in use".

Handler for a 433 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-433-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-433 #[514 "\301\302!>\204\303\304\305D\"\210
\306HA@\307\"\207" [cl-struct-erc-response-tags erc-nickname-in-use type-of signal wrong-type-argument erc-response 4 "already in use"] 7 (#$ . 140288)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-433 definition-name \433 erc-server-433-functions puthash "433"] 4)
#@271 Hook called upon receiving a 437 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-437'.
(defvar erc-server-437-functions nil (#$ . 141013))
(add-hook 'erc-server-437-functions 'erc-server-437)
#@330 Nick temporarily unavailable (on IRCnet).

Handler for a 437 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-437-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-437 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\306
!?\205\307
\310\"\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 erc-channel-p erc-nickname-in-use "temporarily unavailable"] 6 (#$ . 141395)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-437 definition-name \437 erc-server-437-functions puthash "437"] 4)
#@271 Hook called upon receiving a 442 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-442'.
(defvar erc-server-442-functions nil (#$ . 142176))
(add-hook 'erc-server-442-functions 'erc-server-442)
#@304 Not on channel.

Handler for a 442 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-442-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-442 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@&\207" [cl-struct-erc-response-tags erc-display-message (notice error) active s442 99 type-of signal wrong-type-argument erc-response 4] 12 (#$ . 142558)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-442 definition-name \442 erc-server-442-functions puthash "442"] 4)
#@271 Hook called upon receiving a 461 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-461'.
(defvar erc-server-461-functions nil (#$ . 143303))
(add-hook 'erc-server-461-functions 'erc-server-461)
#@323 Not enough parameters for command.

Handler for a 461 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-461-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-461 #[514 "\301
\302\303\304\305\306!>\204\307\310\311	D\"\210\312HA@\313\306	!>\204/\307\310\311D\"\210\314H&\207" [cl-struct-erc-response-tags erc-display-message (notice error) active s461 99 type-of signal wrong-type-argument erc-response 4 109 5] 14 (#$ . 143685)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-461 definition-name \461 erc-server-461-functions puthash "461"] 4)
#@271 Hook called upon receiving a 465 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-465'.
(defvar erc-server-465-functions nil (#$ . 144502))
(add-hook 'erc-server-465-functions 'erc-server-465)
#@321 You are banned from this server.

Handler for a 465 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-465-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-465 #[514 "\302\303
\304!	>\204\305\306\307D\"\210\310H\"\207" [erc-server-banned cl-struct-erc-response-tags t erc-display-error-notice type-of signal wrong-type-argument erc-response 5] 8 (#$ . 144884)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-465 definition-name \465 erc-server-465-functions puthash "465"] 4)
#@271 Hook called upon receiving a 474 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-474'.
(defvar erc-server-474-functions nil (#$ . 145624))
(add-hook 'erc-server-474-functions 'erc-server-474)
#@316 Banned from channel errors.

Handler for a 474 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-474-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-474 #[514 "\301
\302\303\304\305\306\307!>\204\310\311\312\nD\"\210\313H\"!\314\307!>\2040\310\311\312	D\"\210\315HA@&\207" [cl-struct-erc-response-tags erc-display-message (notice error) nil intern format "s%s" type-of signal wrong-type-argument erc-response 3 99 4] 13 (#$ . 146006)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-474 definition-name \474 erc-server-474-functions puthash "474"] 4)
#@271 Hook called upon receiving a 475 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-475'.
(defvar erc-server-475-functions nil (#$ . 146832))
(add-hook 'erc-server-475-functions 'erc-server-475)
#@308 Channel key needed.

Handler for a 475 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-475-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-475 #[514 "\302
\303\304\305\306\307!>\204\310\311\312	D\"\210\313HA@&\210	\205c\307
!>\2043\310\311\312D\"\210\211\313HA@\314\315\316\307!>\204K\310\311\312D\"\210\313HA@\"!\211\205a\211G\317V\205a\320\"\266\202\207" [cl-struct-erc-response-tags erc-prompt-for-channel-key erc-display-message (notice error) nil s475 99 type-of signal wrong-type-argument erc-response 4 read-from-minibuffer format "Channel %s is mode +k.  Enter key (RET to cancel): " 0 erc-cmd-JOIN] 12 (#$ . 147214)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-475 definition-name \475 erc-server-475-functions puthash "475"] 4)
#@271 Hook called upon receiving a 477 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-477'.
(defvar erc-server-477-functions nil (#$ . 148240))
(add-hook 'erc-server-477-functions 'erc-server-477)
#@319 Channel doesn't support modes.

Handler for a 477 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-477-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-477 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\301!>\204#\302\303\304D\"\210
\306H\307\310\311\"\312\313#$\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 5 erc-display-message notice erc-get-buffer format "%s: %s"] 12 (#$ . 148622)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-477 definition-name \477 erc-server-477-functions puthash "477"] 4)
#@271 Hook called upon receiving a 482 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-482'.
(defvar erc-server-482-functions nil (#$ . 149441))
(add-hook 'erc-server-482-functions 'erc-server-482)
#@334 You need to be a channel operator to do that.

Handler for a 482 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-482-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-482 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\301!>\204#\302\303\304D\"\210
\306H\307\310\311\312\313\314&\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 5 erc-display-message (notice error) active s482 99 109] 13 (#$ . 149823)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-482 definition-name \482 erc-server-482-functions puthash "482"] 4)
#@271 Hook called upon receiving a 671 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-671'.
(defvar erc-server-671-functions nil (#$ . 150652))
(add-hook 'erc-server-671-functions 'erc-server-671)
#@325 Secure connection response in WHOIS.

Handler for a 671 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-671-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-671 #[514 "\301
!>\204\302\303\304D\"\210\211\305HA@\301!>\204#\302\303\304D\"\210
\306H\307\310\311\312\313\314&\207" [cl-struct-erc-response-tags type-of signal wrong-type-argument erc-response 4 5 erc-display-message notice active s671 110 97] 13 (#$ . 151034)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\207" [erc-server-responses put erc-server-671 definition-name \671 erc-server-671-functions puthash "671"] 4)
#@271 Hook called upon receiving a 431 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-431-functions nil (#$ . 151846))
(add-hook 'erc-server-431-functions 'erc-server-431)
#@363 Generic display of server error messages.

See `erc-display-error-notice'.

Handler for a 431 server response.
PROC is the server process which returned the response.
PARSED is the actual response as an `erc-response' struct.
If you want to add responses don't modify this function, but rather
add things to `erc-server-431-functions' instead.

(fn PROC PARSED)
(defalias 'erc-server-431 #[514 "\301
\302\303\304\305!>\204\306\307\310D\"\210\311H\"!\"\207" [cl-struct-erc-response-tags erc-display-error-notice intern format "s%s" type-of signal wrong-type-argument erc-response 3] 11 (#$ . 152228)])
(byte-code "\301\302\303\304#\210\301\305\303\304#\210\306\307\305#\210\306\310\311#\210\306\312\313#\210\306\314\315#\210\306\316\317#\210\306\320\321#\210\306\322\323#\210\306\324\325#\210\306\326\327#\210\306\330\331#\210\306\332\333#\210\306\334\335#\210\306\336\337#\210\306\340\341#\210\342\343\302\"\207" [erc-server-responses put erc-server-431 definition-name \431 erc-server-431-functions puthash "431" "445" erc-server-445-functions "446" erc-server-446-functions "451" erc-server-451-functions "462" erc-server-462-functions "463" erc-server-463-functions "464" erc-server-464-functions "481" erc-server-481-functions "483" erc-server-483-functions "484" erc-server-484-functions "485" erc-server-485-functions "491" erc-server-491-functions "501" erc-server-501-functions "502" erc-server-502-functions defalias erc-server-445] 4)
#@271 Hook called upon receiving a 445 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-445-functions 'erc-server-431 (#$ . 153702))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-445-functions definition-name erc-server-431-functions defalias erc-server-446 erc-server-431] 4)
#@271 Hook called upon receiving a 446 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-446-functions 'erc-server-431 (#$ . 154210))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-446-functions definition-name erc-server-431-functions defalias erc-server-451 erc-server-431] 4)
#@271 Hook called upon receiving a 451 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-451-functions 'erc-server-431 (#$ . 154718))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-451-functions definition-name erc-server-431-functions defalias erc-server-462 erc-server-431] 4)
#@271 Hook called upon receiving a 462 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-462-functions 'erc-server-431 (#$ . 155226))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-462-functions definition-name erc-server-431-functions defalias erc-server-463 erc-server-431] 4)
#@271 Hook called upon receiving a 463 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-463-functions 'erc-server-431 (#$ . 155734))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-463-functions definition-name erc-server-431-functions defalias erc-server-464 erc-server-431] 4)
#@271 Hook called upon receiving a 464 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-464-functions 'erc-server-431 (#$ . 156242))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-464-functions definition-name erc-server-431-functions defalias erc-server-481 erc-server-431] 4)
#@271 Hook called upon receiving a 481 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-481-functions 'erc-server-431 (#$ . 156750))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-481-functions definition-name erc-server-431-functions defalias erc-server-483 erc-server-431] 4)
#@271 Hook called upon receiving a 483 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-483-functions 'erc-server-431 (#$ . 157258))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-483-functions definition-name erc-server-431-functions defalias erc-server-484 erc-server-431] 4)
#@271 Hook called upon receiving a 484 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-484-functions 'erc-server-431 (#$ . 157766))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-484-functions definition-name erc-server-431-functions defalias erc-server-485 erc-server-431] 4)
#@271 Hook called upon receiving a 485 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-485-functions 'erc-server-431 (#$ . 158274))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-485-functions definition-name erc-server-431-functions defalias erc-server-491 erc-server-431] 4)
#@271 Hook called upon receiving a 491 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-491-functions 'erc-server-431 (#$ . 158782))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-491-functions definition-name erc-server-431-functions defalias erc-server-501 erc-server-431] 4)
#@271 Hook called upon receiving a 501 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-501-functions 'erc-server-431 (#$ . 159290))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put erc-server-501-functions definition-name erc-server-431-functions defalias erc-server-502 erc-server-431] 4)
#@271 Hook called upon receiving a 502 server response.
Each function is called with two arguments, the process associated
with the response and the parsed response.  If the function returns
non-nil, stop processing the hook.  Otherwise, continue.

See also `erc-server-431'.
(defvar erc-server-502-functions 'erc-server-431 (#$ . 159798))
(byte-code "\300\301\302\303#\210\304\305!\207" [put erc-server-502-functions definition-name erc-server-431-functions provide erc-backend] 4)