#########################################
# THIS FILE IS GENERATED BY make-mod.py #
# DO NOT EDIT IT BY HAND, EDIT EITHER   #
# make-mod.py OR make-mod.header.py     #
# IN THE CODEGEN DIRECTORY, AND RE-GEN  #
#########################################

import typing
from .line import Line, parse_line

#
# This file has been generated from the Earendil IRC Protocol Specification,
# version 0.0
#

class Message:
    __slots__ = ['source']

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode('utf-8')) -> Line:
        raise NotImplementedError('Message.to_line')

    def to_raw(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode('utf-8')) -> bytes:
        return self.to_line().to_raw()

class Unknown(Message):
    __slots__ = ['command', 'arguments']

    def __init__(self, source: str, command: typing.Union[bytes, int], arguments: typing.List[bytes]) -> None:
        self.source = source
        self.command = command
        self.arguments = arguments

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode('utf-8')) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        return Line(source, self.command, self.arguments)

    def __repr__(self) -> str:
        return "Unknown(source={}, command={}, arguments={})".format(repr(self.source), repr(self.command), repr(self.arguments))

def parse_line_message(line: bytes, decode: typing.Callable[[bytes], str] = lambda b: b.decode('utf-8')) -> Message:
    return parse_message(parse_line(line), decode)

#
# make-mod.header.py above ^
# make-mod.py generated code below v
#



def parse_message(line: Line, decode: typing.Callable[[bytes], str] = lambda b: b.decode("utf-8")) -> Message:
    try:
        source = None
        if line.source is not None:
            source = decode(line.source)

    except Exception:
        source = None

    if line.command == b'PASS' and len(line.arguments) == 1: # Pass
        try:
            i = 0
            pass_password = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Pass(source=source, password=pass_password)
        except Exception:
            pass

    if line.command == b'NICK' and len(line.arguments) == 1: # Nick
        try:
            i = 0
            nick_nickname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Nick(source=source, nickname=nick_nickname)
        except Exception:
            pass

    if line.command == b'USER' and len(line.arguments) == 4: # User
        try:
            i = 0
            user_user = decode(line.arguments[i])
            i += 1
            user_mode = int(line.arguments[i])
            i += 1
            # user_line.arguments[i]: '*'
            i += 1
            user_realname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return User(source=source, user=user_user, mode=user_mode, realname=user_realname)
        except Exception:
            pass

    if line.command == b'OPER' and len(line.arguments) == 2: # Oper
        try:
            i = 0
            oper_name = decode(line.arguments[i])
            i += 1
            oper_password = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Oper(source=source, name=oper_name, password=oper_password)
        except Exception:
            pass

    if line.command == b'MODE' and len(line.arguments) == 2: # Mode
        try:
            i = 0
            mode_name = decode(line.arguments[i])
            i += 1
            mode_mode = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Mode(source=source, name=mode_name, mode=mode_mode)
        except Exception:
            pass

    if line.command == b'SERVICE' and len(line.arguments) == 6: # Service
        try:
            i = 0
            service_nickname = decode(line.arguments[i])
            i += 1
            # service_line.arguments[i]: '*'
            i += 1
            service_distribution = decode(line.arguments[i])
            i += 1
            service_type = int(line.arguments[i])
            i += 1
            # service_line.arguments[i]: '0'
            i += 1
            service_info = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Service(source=source, nickname=service_nickname, distribution=service_distribution, type=service_type, info=service_info)
        except Exception:
            pass

    if line.command == b'QUIT' and len(line.arguments) <= 1: # Quit
        try:
            i = 0
            if len(line.arguments) > 0:
                quit_message = decode(line.arguments[i])
                i += 1
            else:
                quit_message = None
            assert i == len(line.arguments)
            return Quit(source=source, message=quit_message)
        except Exception:
            pass

    if line.command == b'SQUIT' and len(line.arguments) == 2: # SQuit
        try:
            i = 0
            s_quit_server = decode(line.arguments[i])
            i += 1
            s_quit_comment = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return SQuit(source=source, server=s_quit_server, comment=s_quit_comment)
        except Exception:
            pass

    if line.command == b'JOIN' and 1 <= len(line.arguments) <= 2: # ChannelJoin
        try:
            i = 0
            channel_join_channels = [decode(x) for x in line.arguments[i].split(b",")]
            i += 1
            if len(line.arguments) > 1:
                channel_join_keys = [decode(x) for x in line.arguments[i].split(b",")]
                i += 1
            else:
                channel_join_keys = None
            assert i == len(line.arguments)
            return ChannelJoin(source=source, channels=channel_join_channels, keys=channel_join_keys)
        except Exception:
            pass

    if line.command == b'PART' and 1 <= len(line.arguments) <= 2: # ChannelPart
        try:
            i = 0
            channel_part_channels = [decode(x) for x in line.arguments[i].split(b",")]
            i += 1
            if len(line.arguments) > 1:
                channel_part_message = decode(line.arguments[i])
                i += 1
            else:
                channel_part_message = None
            assert i == len(line.arguments)
            return ChannelPart(source=source, channels=channel_part_channels, message=channel_part_message)
        except Exception:
            pass

    if line.command == b'TOPIC' and 1 <= len(line.arguments) <= 2: # Topic
        try:
            i = 0
            topic_channel = decode(line.arguments[i])
            i += 1
            if len(line.arguments) > 1:
                topic_topic = decode(line.arguments[i])
                i += 1
            else:
                topic_topic = None
            assert i == len(line.arguments)
            return Topic(source=source, channel=topic_channel, topic=topic_topic)
        except Exception:
            pass

    if line.command == b'NAMES' and len(line.arguments) <= 2: # Names
        try:
            i = 0
            if len(line.arguments) > 0:
                names_channels = [decode(x) for x in line.arguments[i].split(b",")]
                i += 1
            else:
                names_channels = None
            if len(line.arguments) > 1:
                names_target = decode(line.arguments[i])
                i += 1
            else:
                names_target = None
            assert i == len(line.arguments)
            return Names(source=source, channels=names_channels, target=names_target)
        except Exception:
            pass

    if line.command == b'LIST' and len(line.arguments) <= 2: # List
        try:
            i = 0
            if len(line.arguments) > 0:
                list_channels = [decode(x) for x in line.arguments[i].split(b",")]
                i += 1
            else:
                list_channels = None
            if len(line.arguments) > 1:
                list_target = decode(line.arguments[i])
                i += 1
            else:
                list_target = None
            assert i == len(line.arguments)
            return List(source=source, channels=list_channels, target=list_target)
        except Exception:
            pass

    if line.command == b'INVITE' and len(line.arguments) == 2: # Invite
        try:
            i = 0
            invite_nickname = decode(line.arguments[i])
            i += 1
            invite_channel = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Invite(source=source, nickname=invite_nickname, channel=invite_channel)
        except Exception:
            pass

    if line.command == b'KICK' and 2 <= len(line.arguments) <= 3: # Kick
        try:
            i = 0
            kick_channels = [decode(x) for x in line.arguments[i].split(b",")]
            i += 1
            kick_users = [decode(x) for x in line.arguments[i].split(b",")]
            i += 1
            if len(line.arguments) > 2:
                kick_comment = decode(line.arguments[i])
                i += 1
            else:
                kick_comment = None
            assert i == len(line.arguments)
            return Kick(source=source, channels=kick_channels, users=kick_users, comment=kick_comment)
        except Exception:
            pass

    if line.command == b'PRIVMSG' and len(line.arguments) == 2: # Privmsg
        try:
            i = 0
            privmsg_target = decode(line.arguments[i])
            i += 1
            privmsg_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Privmsg(source=source, target=privmsg_target, message=privmsg_message)
        except Exception:
            pass

    if line.command == b'NOTICE' and len(line.arguments) == 2: # Notice
        try:
            i = 0
            notice_target = decode(line.arguments[i])
            i += 1
            notice_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Notice(source=source, target=notice_target, message=notice_message)
        except Exception:
            pass

    if line.command == b'MOTD' and len(line.arguments) <= 1: # Motd
        try:
            i = 0
            if len(line.arguments) > 0:
                motd_target = decode(line.arguments[i])
                i += 1
            else:
                motd_target = None
            assert i == len(line.arguments)
            return Motd(source=source, target=motd_target)
        except Exception:
            pass

    if line.command == b'LUSERS' and len(line.arguments) <= 2: # Lusers
        try:
            i = 0
            if len(line.arguments) > 0:
                lusers_mask = decode(line.arguments[i])
                i += 1
            else:
                lusers_mask = None
            if len(line.arguments) > 1:
                lusers_target = decode(line.arguments[i])
                i += 1
            else:
                lusers_target = None
            assert i == len(line.arguments)
            return Lusers(source=source, mask=lusers_mask, target=lusers_target)
        except Exception:
            pass

    if line.command == b'VERSION' and len(line.arguments) <= 1: # Version
        try:
            i = 0
            if len(line.arguments) > 0:
                version_target = decode(line.arguments[i])
                i += 1
            else:
                version_target = None
            assert i == len(line.arguments)
            return Version(source=source, target=version_target)
        except Exception:
            pass

    if line.command == b'STATS' and len(line.arguments) <= 2: # Stats
        try:
            i = 0
            if len(line.arguments) > 0:
                stats_query = decode(line.arguments[i])
                i += 1
            else:
                stats_query = None
            if len(line.arguments) > 1:
                stats_target = decode(line.arguments[i])
                i += 1
            else:
                stats_target = None
            assert i == len(line.arguments)
            return Stats(source=source, query=stats_query, target=stats_target)
        except Exception:
            pass

    if line.command == b'LINKS' and len(line.arguments) <= 2: # Links
        try:
            i = len(line.arguments) - 1
            if len(line.arguments) > 0:
                links_server = decode(line.arguments[i])
                i -= 1
            else:
                links_server = None
            if len(line.arguments) > 1:
                links_mask = decode(line.arguments[i])
                i -= 1
            else:
                links_mask = None
            assert i == -1
            return Links(source=source, server=links_server, mask=links_mask)
        except Exception:
            pass

    if line.command == b'TIME' and len(line.arguments) <= 1: # Time
        try:
            i = 0
            if len(line.arguments) > 0:
                time_target = decode(line.arguments[i])
                i += 1
            else:
                time_target = None
            assert i == len(line.arguments)
            return Time(source=source, target=time_target)
        except Exception:
            pass

    if line.command == b'CONNECT' and 2 <= len(line.arguments) <= 3: # ServerConnect
        try:
            i = 0
            server_connect_target = decode(line.arguments[i])
            i += 1
            server_connect_port = int(line.arguments[i])
            i += 1
            if len(line.arguments) > 2:
                server_connect_remote = decode(line.arguments[i])
                i += 1
            else:
                server_connect_remote = None
            assert i == len(line.arguments)
            return ServerConnect(source=source, target=server_connect_target, port=server_connect_port, remote=server_connect_remote)
        except Exception:
            pass

    if line.command == b'TRACE' and len(line.arguments) <= 1: # Trace
        try:
            i = 0
            if len(line.arguments) > 0:
                trace_target = decode(line.arguments[i])
                i += 1
            else:
                trace_target = None
            assert i == len(line.arguments)
            return Trace(source=source, target=trace_target)
        except Exception:
            pass

    if line.command == b'ADMIN' and len(line.arguments) <= 1: # Admin
        try:
            i = 0
            if len(line.arguments) > 0:
                admin_target = decode(line.arguments[i])
                i += 1
            else:
                admin_target = None
            assert i == len(line.arguments)
            return Admin(source=source, target=admin_target)
        except Exception:
            pass

    if line.command == b'INFO' and len(line.arguments) <= 1: # Info
        try:
            i = 0
            if len(line.arguments) > 0:
                info_target = decode(line.arguments[i])
                i += 1
            else:
                info_target = None
            assert i == len(line.arguments)
            return Info(source=source, target=info_target)
        except Exception:
            pass

    if line.command == b'SERVLIST' and len(line.arguments) <= 2: # ServList
        try:
            i = 0
            if len(line.arguments) > 0:
                serv_list_mask = decode(line.arguments[i])
                i += 1
            else:
                serv_list_mask = None
            if len(line.arguments) > 1:
                serv_list_type = decode(line.arguments[i])
                i += 1
            else:
                serv_list_type = None
            assert i == len(line.arguments)
            return ServList(source=source, mask=serv_list_mask, type=serv_list_type)
        except Exception:
            pass

    if line.command == b'SQUERY' and len(line.arguments) == 2: # SQuery
        try:
            i = 0
            s_query_servicename = decode(line.arguments[i])
            i += 1
            s_query_text = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return SQuery(source=source, servicename=s_query_servicename, text=s_query_text)
        except Exception:
            pass

    if line.command == b'WHO' and len(line.arguments) <= 2: # Who
        try:
            i = 0
            if len(line.arguments) > 0:
                who_mask = decode(line.arguments[i])
                i += 1
            else:
                who_mask = None
            if len(line.arguments) > 1:
                who_operators = True
                i += 1
            else:
                who_operators = False
            assert i == len(line.arguments)
            return Who(source=source, mask=who_mask, operators=who_operators)
        except Exception:
            pass

    if line.command == b'WHOIS' and 1 <= len(line.arguments) <= 2: # WhoIs
        try:
            i = 0
            if len(line.arguments) > 1:
                who_is_target = decode(line.arguments[i])
                i += 1
            else:
                who_is_target = None
            who_is_masks = [decode(x) for x in line.arguments[i].split(b",")]
            i += 1
            assert i == len(line.arguments)
            return WhoIs(source=source, target=who_is_target, masks=who_is_masks)
        except Exception:
            pass

    if line.command == b'WHOWAS' and 1 <= len(line.arguments) <= 3: # WhoWas
        try:
            i = 0
            who_was_nicknames = [decode(x) for x in line.arguments[i].split(b",")]
            i += 1
            if len(line.arguments) > 1:
                who_was_count = int(line.arguments[i])
                i += 1
            else:
                who_was_count = None
            if len(line.arguments) > 2:
                who_was_target = decode(line.arguments[i])
                i += 1
            else:
                who_was_target = None
            assert i == len(line.arguments)
            return WhoWas(source=source, nicknames=who_was_nicknames, count=who_was_count, target=who_was_target)
        except Exception:
            pass

    if line.command == b'KILL' and len(line.arguments) == 2: # Kill
        try:
            i = 0
            kill_nickname = decode(line.arguments[i])
            i += 1
            kill_comment = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Kill(source=source, nickname=kill_nickname, comment=kill_comment)
        except Exception:
            pass

    if line.command == b'PING' and 1 <= len(line.arguments) <= 2: # Ping
        try:
            i = 0
            ping_server1 = decode(line.arguments[i])
            i += 1
            if len(line.arguments) > 1:
                ping_server2 = decode(line.arguments[i])
                i += 1
            else:
                ping_server2 = None
            assert i == len(line.arguments)
            return Ping(source=source, server1=ping_server1, server2=ping_server2)
        except Exception:
            pass

    if line.command == b'PONG' and 1 <= len(line.arguments) <= 2: # Pong
        try:
            i = 0
            pong_server = decode(line.arguments[i])
            i += 1
            if len(line.arguments) > 1:
                pong_server2 = decode(line.arguments[i])
                i += 1
            else:
                pong_server2 = None
            assert i == len(line.arguments)
            return Pong(source=source, server=pong_server, server2=pong_server2)
        except Exception:
            pass

    if line.command == b'ERROR' and len(line.arguments) == 1: # Error
        try:
            i = 0
            error_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Error(source=source, message=error_message)
        except Exception:
            pass

    if line.command == b'AWAY' and len(line.arguments) <= 1: # Away
        try:
            i = 0
            if len(line.arguments) > 0:
                away_text = decode(line.arguments[i])
                i += 1
            else:
                away_text = None
            assert i == len(line.arguments)
            return Away(source=source, text=away_text)
        except Exception:
            pass

    if line.command == b'REHASH' and len(line.arguments) == 0: # Rehash
        try:
            return Rehash(source=source)
        except Exception:
            pass

    if line.command == b'DIE' and len(line.arguments) == 0: # Die
        try:
            return Die(source=source)
        except Exception:
            pass

    if line.command == b'RESTART' and len(line.arguments) == 0: # Restart
        try:
            return Restart(source=source)
        except Exception:
            pass

    if line.command == b'SUMMON' and 1 <= len(line.arguments) <= 3: # Summon
        try:
            i = 0
            summon_user = decode(line.arguments[i])
            i += 1
            if len(line.arguments) > 1:
                summon_target = decode(line.arguments[i])
                i += 1
            else:
                summon_target = None
            if len(line.arguments) > 2:
                summon_channel = decode(line.arguments[i])
                i += 1
            else:
                summon_channel = None
            assert i == len(line.arguments)
            return Summon(source=source, user=summon_user, target=summon_target, channel=summon_channel)
        except Exception:
            pass

    if line.command == b'USERS' and len(line.arguments) <= 1: # Users
        try:
            i = 0
            if len(line.arguments) > 0:
                users_target = decode(line.arguments[i])
                i += 1
            else:
                users_target = None
            assert i == len(line.arguments)
            return Users(source=source, target=users_target)
        except Exception:
            pass

    if line.command == b'WALLOPS' and len(line.arguments) == 1: # WallOps
        try:
            i = 0
            wall_ops_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return WallOps(source=source, message=wall_ops_message)
        except Exception:
            pass

    if line.command == b'USERHOST' and len(line.arguments) == 1: # UserHost
        try:
            i = 0
            user_host_nickname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return UserHost(source=source, nickname=user_host_nickname)
        except Exception:
            pass

    if line.command == b'ISON' and len(line.arguments) == 1: # IsOn
        try:
            i = 0
            is_on_nickname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return IsOn(source=source, nickname=is_on_nickname)
        except Exception:
            pass

    if line.command == 1 and len(line.arguments) == 2: # Welcome
        try:
            i = 0
            welcome_target = decode(line.arguments[i])
            i += 1
            welcome_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Welcome(source=source, target=welcome_target, message=welcome_message)
        except Exception:
            pass

    if line.command == 2 and len(line.arguments) == 2: # YourHost
        try:
            i = 0
            your_host_target = decode(line.arguments[i])
            i += 1
            your_host_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return YourHost(source=source, target=your_host_target, message=your_host_message)
        except Exception:
            pass

    if line.command == 3 and len(line.arguments) == 2: # Created
        try:
            i = 0
            created_target = decode(line.arguments[i])
            i += 1
            created_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Created(source=source, target=created_target, message=created_message)
        except Exception:
            pass

    if line.command == 4 and len(line.arguments) == 2: # MyInfo
        try:
            i = 0
            my_info_target = decode(line.arguments[i])
            i += 1
            my_info_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return MyInfo(source=source, target=my_info_target, message=my_info_message)
        except Exception:
            pass

    if line.command == 5 and len(line.arguments) == 2: # Bounce
        try:
            i = 0
            bounce_target = decode(line.arguments[i])
            i += 1
            bounce_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Bounce(source=source, target=bounce_target, message=bounce_message)
        except Exception:
            pass

    if line.command == 200 and len(line.arguments) == 9: # TraceLinkReply
        try:
            i = 0
            trace_link_reply_target = decode(line.arguments[i])
            i += 1
            # trace_link_reply_line.arguments[i]: 'Link'
            i += 1
            trace_link_reply_version = decode(line.arguments[i])
            i += 1
            trace_link_reply_destination = decode(line.arguments[i])
            i += 1
            trace_link_reply_next = decode(line.arguments[i])
            i += 1
            trace_link_reply_protocol_version = decode(line.arguments[i])
            i += 1
            trace_link_reply_link_uptime = decode(line.arguments[i])
            i += 1
            trace_link_reply_back_send_q = decode(line.arguments[i])
            i += 1
            trace_link_reply_up_send_q = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceLinkReply(source=source, target=trace_link_reply_target, version=trace_link_reply_version, destination=trace_link_reply_destination, next=trace_link_reply_next, protocol_version=trace_link_reply_protocol_version, link_uptime=trace_link_reply_link_uptime, back_send_q=trace_link_reply_back_send_q, up_send_q=trace_link_reply_up_send_q)
        except Exception:
            pass

    if line.command == 201 and len(line.arguments) == 4: # TraceConnecting
        try:
            i = 0
            trace_connecting_target = decode(line.arguments[i])
            i += 1
            # trace_connecting_line.arguments[i]: 'Try.'
            i += 1
            trace_connecting_cls = decode(line.arguments[i])
            i += 1
            trace_connecting_server = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceConnecting(source=source, target=trace_connecting_target, cls=trace_connecting_cls, server=trace_connecting_server)
        except Exception:
            pass

    if line.command == 202 and len(line.arguments) == 4: # TraceHandshake
        try:
            i = 0
            trace_handshake_target = decode(line.arguments[i])
            i += 1
            # trace_handshake_line.arguments[i]: 'H.S.'
            i += 1
            trace_handshake_cls = decode(line.arguments[i])
            i += 1
            trace_handshake_server = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceHandshake(source=source, target=trace_handshake_target, cls=trace_handshake_cls, server=trace_handshake_server)
        except Exception:
            pass

    if line.command == 203 and 3 <= len(line.arguments) <= 4: # TraceUnknown
        try:
            i = 0
            trace_unknown_target = decode(line.arguments[i])
            i += 1
            # trace_unknown_line.arguments[i]: '????'
            i += 1
            trace_unknown_cls = decode(line.arguments[i])
            i += 1
            if len(line.arguments) > 3:
                trace_unknown_ip = decode(line.arguments[i])
                i += 1
            else:
                trace_unknown_ip = None
            assert i == len(line.arguments)
            return TraceUnknown(source=source, target=trace_unknown_target, cls=trace_unknown_cls, ip=trace_unknown_ip)
        except Exception:
            pass

    if line.command == 204 and len(line.arguments) == 4: # TraceOperator
        try:
            i = 0
            trace_operator_target = decode(line.arguments[i])
            i += 1
            # trace_operator_line.arguments[i]: 'Oper'
            i += 1
            trace_operator_cls = decode(line.arguments[i])
            i += 1
            trace_operator_nickname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceOperator(source=source, target=trace_operator_target, cls=trace_operator_cls, nickname=trace_operator_nickname)
        except Exception:
            pass

    if line.command == 205 and len(line.arguments) == 4: # TraceUser
        try:
            i = 0
            trace_user_target = decode(line.arguments[i])
            i += 1
            # trace_user_line.arguments[i]: 'User'
            i += 1
            trace_user_cls = decode(line.arguments[i])
            i += 1
            trace_user_nickname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceUser(source=source, target=trace_user_target, cls=trace_user_cls, nickname=trace_user_nickname)
        except Exception:
            pass

    if line.command == 206 and len(line.arguments) == 8: # TraceServer
        try:
            i = 0
            trace_server_target = decode(line.arguments[i])
            i += 1
            # trace_server_line.arguments[i]: 'Serv'
            i += 1
            trace_server_cls = decode(line.arguments[i])
            i += 1
            trace_server_s = decode(line.arguments[i])
            i += 1
            trace_server_c = decode(line.arguments[i])
            i += 1
            trace_server_server = decode(line.arguments[i])
            i += 1
            trace_server_hostmask = decode(line.arguments[i])
            i += 1
            trace_server_protocol_version = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceServer(source=source, target=trace_server_target, cls=trace_server_cls, s=trace_server_s, c=trace_server_c, server=trace_server_server, hostmask=trace_server_hostmask, protocol_version=trace_server_protocol_version)
        except Exception:
            pass

    if line.command == 207 and len(line.arguments) == 6: # TraceService
        try:
            i = 0
            trace_service_target = decode(line.arguments[i])
            i += 1
            # trace_service_line.arguments[i]: 'Service'
            i += 1
            trace_service_cls = decode(line.arguments[i])
            i += 1
            trace_service_name = decode(line.arguments[i])
            i += 1
            trace_service_type = decode(line.arguments[i])
            i += 1
            trace_service_active_type = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceService(source=source, target=trace_service_target, cls=trace_service_cls, name=trace_service_name, type=trace_service_type, active_type=trace_service_active_type)
        except Exception:
            pass

    if line.command == 208 and len(line.arguments) == 4: # TraceNewtype
        try:
            i = 0
            trace_newtype_target = decode(line.arguments[i])
            i += 1
            trace_newtype_newtype = decode(line.arguments[i])
            i += 1
            # trace_newtype_line.arguments[i]: '0'
            i += 1
            trace_newtype_name = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceNewtype(source=source, target=trace_newtype_target, newtype=trace_newtype_newtype, name=trace_newtype_name)
        except Exception:
            pass

    if line.command == 209 and len(line.arguments) == 4: # TraceClass
        try:
            i = 0
            trace_class_target = decode(line.arguments[i])
            i += 1
            # trace_class_line.arguments[i]: 'Class'
            i += 1
            trace_class_cls = decode(line.arguments[i])
            i += 1
            trace_class_count = int(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceClass(source=source, target=trace_class_target, cls=trace_class_cls, count=trace_class_count)
        except Exception:
            pass

    if line.command == 211 and len(line.arguments) == 8: # StatsLinkInfo
        try:
            i = 0
            stats_link_info_target = decode(line.arguments[i])
            i += 1
            stats_link_info_name = decode(line.arguments[i])
            i += 1
            stats_link_info_sendq = decode(line.arguments[i])
            i += 1
            stats_link_info_sent_messages = int(line.arguments[i])
            i += 1
            stats_link_info_sent_kbytes = int(line.arguments[i])
            i += 1
            stats_link_info_recv_messages = int(line.arguments[i])
            i += 1
            stats_link_info_recv_kbytes = int(line.arguments[i])
            i += 1
            stats_link_info_uptime = int(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return StatsLinkInfo(source=source, target=stats_link_info_target, name=stats_link_info_name, sendq=stats_link_info_sendq, sent_messages=stats_link_info_sent_messages, sent_kbytes=stats_link_info_sent_kbytes, recv_messages=stats_link_info_recv_messages, recv_kbytes=stats_link_info_recv_kbytes, uptime=stats_link_info_uptime)
        except Exception:
            pass

    if line.command == 212 and len(line.arguments) == 5: # StatsCommands
        try:
            i = 0
            stats_commands_target = decode(line.arguments[i])
            i += 1
            stats_commands_command = decode(line.arguments[i])
            i += 1
            stats_commands_count = int(line.arguments[i])
            i += 1
            stats_commands_bytecount = int(line.arguments[i])
            i += 1
            stats_commands_remote_count = int(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return StatsCommands(source=source, target=stats_commands_target, command=stats_commands_command, count=stats_commands_count, bytecount=stats_commands_bytecount, remote_count=stats_commands_remote_count)
        except Exception:
            pass

    if line.command == 219 and len(line.arguments) == 3: # StatsEnd
        try:
            i = 0
            stats_end_target = decode(line.arguments[i])
            i += 1
            stats_end_letter = decode(line.arguments[i])
            i += 1
            # stats_end_line.arguments[i]: 'End of STATS report'
            i += 1
            assert i == len(line.arguments)
            return StatsEnd(source=source, target=stats_end_target, letter=stats_end_letter)
        except Exception:
            pass

    if line.command == 221 and len(line.arguments) == 2: # UserModeIs
        try:
            i = 0
            user_mode_is_target = decode(line.arguments[i])
            i += 1
            user_mode_is_mode = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return UserModeIs(source=source, target=user_mode_is_target, mode=user_mode_is_mode)
        except Exception:
            pass

    if line.command == 234 and len(line.arguments) == 7: # ServListReply
        try:
            i = 0
            serv_list_reply_target = decode(line.arguments[i])
            i += 1
            serv_list_reply_name = decode(line.arguments[i])
            i += 1
            serv_list_reply_server = decode(line.arguments[i])
            i += 1
            serv_list_reply_mask = decode(line.arguments[i])
            i += 1
            serv_list_reply_type = decode(line.arguments[i])
            i += 1
            serv_list_reply_hopcount = int(line.arguments[i])
            i += 1
            serv_list_reply_info = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return ServListReply(source=source, target=serv_list_reply_target, name=serv_list_reply_name, server=serv_list_reply_server, mask=serv_list_reply_mask, type=serv_list_reply_type, hopcount=serv_list_reply_hopcount, info=serv_list_reply_info)
        except Exception:
            pass

    if line.command == 235 and len(line.arguments) == 4: # ServListEnd
        try:
            i = 0
            serv_list_end_target = decode(line.arguments[i])
            i += 1
            serv_list_end_mask = decode(line.arguments[i])
            i += 1
            serv_list_end_type = decode(line.arguments[i])
            i += 1
            # serv_list_end_line.arguments[i]: 'End of service listing'
            i += 1
            assert i == len(line.arguments)
            return ServListEnd(source=source, target=serv_list_end_target, mask=serv_list_end_mask, type=serv_list_end_type)
        except Exception:
            pass

    if line.command == 242 and len(line.arguments) == 2: # StatsUptime
        try:
            i = 0
            stats_uptime_target = decode(line.arguments[i])
            i += 1
            stats_uptime_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return StatsUptime(source=source, target=stats_uptime_target, message=stats_uptime_message)
        except Exception:
            pass

    if line.command == 243 and len(line.arguments) == 5: # StatsOline
        try:
            i = 0
            stats_oline_target = decode(line.arguments[i])
            i += 1
            # stats_oline_line.arguments[i]: 'O'
            i += 1
            stats_oline_hostmask = decode(line.arguments[i])
            i += 1
            # stats_oline_line.arguments[i]: '*'
            i += 1
            stats_oline_name = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return StatsOline(source=source, target=stats_oline_target, hostmask=stats_oline_hostmask, name=stats_oline_name)
        except Exception:
            pass

    if line.command == 251 and len(line.arguments) == 2: # LuserClient
        try:
            i = 0
            luser_client_target = decode(line.arguments[i])
            i += 1
            luser_client_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return LuserClient(source=source, target=luser_client_target, message=luser_client_message)
        except Exception:
            pass

    if line.command == 252 and len(line.arguments) == 3: # LuserOp
        try:
            i = 0
            luser_op_target = decode(line.arguments[i])
            i += 1
            luser_op_count = int(line.arguments[i])
            i += 1
            # luser_op_line.arguments[i]: 'operator(s) online'
            i += 1
            assert i == len(line.arguments)
            return LuserOp(source=source, target=luser_op_target, count=luser_op_count)
        except Exception:
            pass

    if line.command == 253 and len(line.arguments) == 3: # LuserUnknown
        try:
            i = 0
            luser_unknown_target = decode(line.arguments[i])
            i += 1
            luser_unknown_count = int(line.arguments[i])
            i += 1
            # luser_unknown_line.arguments[i]: 'unknown connection(s)'
            i += 1
            assert i == len(line.arguments)
            return LuserUnknown(source=source, target=luser_unknown_target, count=luser_unknown_count)
        except Exception:
            pass

    if line.command == 254 and len(line.arguments) == 3: # LuserChannels
        try:
            i = 0
            luser_channels_target = decode(line.arguments[i])
            i += 1
            luser_channels_count = int(line.arguments[i])
            i += 1
            # luser_channels_line.arguments[i]: 'channels formed'
            i += 1
            assert i == len(line.arguments)
            return LuserChannels(source=source, target=luser_channels_target, count=luser_channels_count)
        except Exception:
            pass

    if line.command == 255 and len(line.arguments) == 2: # LuserMe
        try:
            i = 0
            luser_me_target = decode(line.arguments[i])
            i += 1
            luser_me_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return LuserMe(source=source, target=luser_me_target, message=luser_me_message)
        except Exception:
            pass

    if line.command == 256 and len(line.arguments) == 3: # AdminMe
        try:
            i = 0
            admin_me_target = decode(line.arguments[i])
            i += 1
            admin_me_server = decode(line.arguments[i])
            i += 1
            # admin_me_line.arguments[i]: 'Administrative info'
            i += 1
            assert i == len(line.arguments)
            return AdminMe(source=source, target=admin_me_target, server=admin_me_server)
        except Exception:
            pass

    if line.command == 257 and len(line.arguments) == 2: # AdminLoc1
        try:
            i = 0
            admin_loc1_target = decode(line.arguments[i])
            i += 1
            admin_loc1_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return AdminLoc1(source=source, target=admin_loc1_target, message=admin_loc1_message)
        except Exception:
            pass

    if line.command == 258 and len(line.arguments) == 2: # AdminLoc2
        try:
            i = 0
            admin_loc2_target = decode(line.arguments[i])
            i += 1
            admin_loc2_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return AdminLoc2(source=source, target=admin_loc2_target, message=admin_loc2_message)
        except Exception:
            pass

    if line.command == 259 and len(line.arguments) == 2: # AdminEmail
        try:
            i = 0
            admin_email_target = decode(line.arguments[i])
            i += 1
            admin_email_email = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return AdminEmail(source=source, target=admin_email_target, email=admin_email_email)
        except Exception:
            pass

    if line.command == 261 and len(line.arguments) == 4: # TraceLog
        try:
            i = 0
            trace_log_target = decode(line.arguments[i])
            i += 1
            # trace_log_line.arguments[i]: 'File'
            i += 1
            trace_log_logfile = decode(line.arguments[i])
            i += 1
            trace_log_debug_level = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TraceLog(source=source, target=trace_log_target, logfile=trace_log_logfile, debug_level=trace_log_debug_level)
        except Exception:
            pass

    if line.command == 262 and len(line.arguments) == 4: # TraceEnd
        try:
            i = 0
            trace_end_target = decode(line.arguments[i])
            i += 1
            trace_end_server = decode(line.arguments[i])
            i += 1
            trace_end_version = decode(line.arguments[i])
            i += 1
            # trace_end_line.arguments[i]: 'End of TRACE'
            i += 1
            assert i == len(line.arguments)
            return TraceEnd(source=source, target=trace_end_target, server=trace_end_server, version=trace_end_version)
        except Exception:
            pass

    if line.command == 263 and len(line.arguments) == 3: # TryAgain
        try:
            i = 0
            try_again_target = decode(line.arguments[i])
            i += 1
            try_again_command = decode(line.arguments[i])
            i += 1
            # try_again_line.arguments[i]: 'Please wait a while and try again.'
            i += 1
            assert i == len(line.arguments)
            return TryAgain(source=source, target=try_again_target, command=try_again_command)
        except Exception:
            pass

    if line.command == 301 and len(line.arguments) == 3: # AwayReply
        try:
            i = 0
            away_reply_target = decode(line.arguments[i])
            i += 1
            away_reply_nickname = decode(line.arguments[i])
            i += 1
            away_reply_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return AwayReply(source=source, target=away_reply_target, nickname=away_reply_nickname, message=away_reply_message)
        except Exception:
            pass

    if line.command == 302 and len(line.arguments) == 2: # UserHostReply
        try:
            i = 0
            user_host_reply_target = decode(line.arguments[i])
            i += 1
            user_host_reply_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return UserHostReply(source=source, target=user_host_reply_target, message=user_host_reply_message)
        except Exception:
            pass

    if line.command == 303 and len(line.arguments) == 2: # IsOnReply
        try:
            i = 0
            is_on_reply_target = decode(line.arguments[i])
            i += 1
            is_on_reply_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return IsOnReply(source=source, target=is_on_reply_target, message=is_on_reply_message)
        except Exception:
            pass

    if line.command == 305 and len(line.arguments) == 2: # UnawayReply
        try:
            i = 0
            unaway_reply_target = decode(line.arguments[i])
            i += 1
            # unaway_reply_line.arguments[i]: 'You are no longer marked as being away'
            i += 1
            assert i == len(line.arguments)
            return UnawayReply(source=source, target=unaway_reply_target)
        except Exception:
            pass

    if line.command == 306 and len(line.arguments) == 2: # NowAwayReply
        try:
            i = 0
            now_away_reply_target = decode(line.arguments[i])
            i += 1
            # now_away_reply_line.arguments[i]: 'You have been marked as being away'
            i += 1
            assert i == len(line.arguments)
            return NowAwayReply(source=source, target=now_away_reply_target)
        except Exception:
            pass

    if line.command == 311 and len(line.arguments) == 6: # WhoIsUser
        try:
            i = 0
            who_is_user_target = decode(line.arguments[i])
            i += 1
            who_is_user_nickname = decode(line.arguments[i])
            i += 1
            who_is_user_user = decode(line.arguments[i])
            i += 1
            who_is_user_host = decode(line.arguments[i])
            i += 1
            # who_is_user_line.arguments[i]: '*'
            i += 1
            who_is_user_realname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return WhoIsUser(source=source, target=who_is_user_target, nickname=who_is_user_nickname, user=who_is_user_user, host=who_is_user_host, realname=who_is_user_realname)
        except Exception:
            pass

    if line.command == 312 and len(line.arguments) == 4: # WhoIsServer
        try:
            i = 0
            who_is_server_target = decode(line.arguments[i])
            i += 1
            who_is_server_nickname = decode(line.arguments[i])
            i += 1
            who_is_server_server = decode(line.arguments[i])
            i += 1
            who_is_server_info = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return WhoIsServer(source=source, target=who_is_server_target, nickname=who_is_server_nickname, server=who_is_server_server, info=who_is_server_info)
        except Exception:
            pass

    if line.command == 313 and len(line.arguments) == 3: # WhoIsOperator
        try:
            i = 0
            who_is_operator_target = decode(line.arguments[i])
            i += 1
            who_is_operator_nickname = decode(line.arguments[i])
            i += 1
            # who_is_operator_line.arguments[i]: 'is an IRC operator'
            i += 1
            assert i == len(line.arguments)
            return WhoIsOperator(source=source, target=who_is_operator_target, nickname=who_is_operator_nickname)
        except Exception:
            pass

    if line.command == 314 and len(line.arguments) == 6: # WhoWasUser
        try:
            i = 0
            who_was_user_target = decode(line.arguments[i])
            i += 1
            who_was_user_nickname = decode(line.arguments[i])
            i += 1
            who_was_user_user = decode(line.arguments[i])
            i += 1
            who_was_user_host = decode(line.arguments[i])
            i += 1
            # who_was_user_line.arguments[i]: '*'
            i += 1
            who_was_user_realname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return WhoWasUser(source=source, target=who_was_user_target, nickname=who_was_user_nickname, user=who_was_user_user, host=who_was_user_host, realname=who_was_user_realname)
        except Exception:
            pass

    if line.command == 315 and len(line.arguments) == 3: # WhoEnd
        try:
            i = 0
            who_end_target = decode(line.arguments[i])
            i += 1
            who_end_name = decode(line.arguments[i])
            i += 1
            # who_end_line.arguments[i]: 'End of WHO list'
            i += 1
            assert i == len(line.arguments)
            return WhoEnd(source=source, target=who_end_target, name=who_end_name)
        except Exception:
            pass

    if line.command == 317 and len(line.arguments) == 4: # WhoIsIdle
        try:
            i = 0
            who_is_idle_target = decode(line.arguments[i])
            i += 1
            who_is_idle_nickname = decode(line.arguments[i])
            i += 1
            who_is_idle_time = int(line.arguments[i])
            i += 1
            # who_is_idle_line.arguments[i]: 'seconds idle'
            i += 1
            assert i == len(line.arguments)
            return WhoIsIdle(source=source, target=who_is_idle_target, nickname=who_is_idle_nickname, time=who_is_idle_time)
        except Exception:
            pass

    if line.command == 318 and len(line.arguments) == 3: # WhoIsEnd
        try:
            i = 0
            who_is_end_target = decode(line.arguments[i])
            i += 1
            who_is_end_nickname = decode(line.arguments[i])
            i += 1
            # who_is_end_line.arguments[i]: 'End of WHOIS list'
            i += 1
            assert i == len(line.arguments)
            return WhoIsEnd(source=source, target=who_is_end_target, nickname=who_is_end_nickname)
        except Exception:
            pass

    if line.command == 319 and len(line.arguments) == 3: # WhoIsChannels
        try:
            i = 0
            who_is_channels_target = decode(line.arguments[i])
            i += 1
            who_is_channels_nickname = decode(line.arguments[i])
            i += 1
            who_is_channels_channels = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return WhoIsChannels(source=source, target=who_is_channels_target, nickname=who_is_channels_nickname, channels=who_is_channels_channels)
        except Exception:
            pass

    if line.command == 322 and len(line.arguments) == 4: # ListReply
        try:
            i = 0
            list_reply_target = decode(line.arguments[i])
            i += 1
            list_reply_channel = decode(line.arguments[i])
            i += 1
            list_reply_visible = int(line.arguments[i])
            i += 1
            list_reply_topic = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return ListReply(source=source, target=list_reply_target, channel=list_reply_channel, visible=list_reply_visible, topic=list_reply_topic)
        except Exception:
            pass

    if line.command == 323 and len(line.arguments) == 2: # ListEnd
        try:
            i = 0
            list_end_target = decode(line.arguments[i])
            i += 1
            # list_end_line.arguments[i]: 'End of LIST'
            i += 1
            assert i == len(line.arguments)
            return ListEnd(source=source, target=list_end_target)
        except Exception:
            pass

    if line.command == 324 and len(line.arguments) == 4: # ChannelModeIs
        try:
            i = 0
            channel_mode_is_target = decode(line.arguments[i])
            i += 1
            channel_mode_is_channel = decode(line.arguments[i])
            i += 1
            channel_mode_is_mode = decode(line.arguments[i])
            i += 1
            channel_mode_is_params = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return ChannelModeIs(source=source, target=channel_mode_is_target, channel=channel_mode_is_channel, mode=channel_mode_is_mode, params=channel_mode_is_params)
        except Exception:
            pass

    if line.command == 325 and len(line.arguments) == 3: # UniqOpIs
        try:
            i = 0
            uniq_op_is_target = decode(line.arguments[i])
            i += 1
            uniq_op_is_channel = decode(line.arguments[i])
            i += 1
            uniq_op_is_nickname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return UniqOpIs(source=source, target=uniq_op_is_target, channel=uniq_op_is_channel, nickname=uniq_op_is_nickname)
        except Exception:
            pass

    if line.command == 331 and len(line.arguments) == 3: # NoTopicReply
        try:
            i = 0
            no_topic_reply_target = decode(line.arguments[i])
            i += 1
            no_topic_reply_channel = decode(line.arguments[i])
            i += 1
            # no_topic_reply_line.arguments[i]: 'No topic is set'
            i += 1
            assert i == len(line.arguments)
            return NoTopicReply(source=source, target=no_topic_reply_target, channel=no_topic_reply_channel)
        except Exception:
            pass

    if line.command == 332 and len(line.arguments) == 3: # TopicReply
        try:
            i = 0
            topic_reply_target = decode(line.arguments[i])
            i += 1
            topic_reply_channel = decode(line.arguments[i])
            i += 1
            topic_reply_topic = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TopicReply(source=source, target=topic_reply_target, channel=topic_reply_channel, topic=topic_reply_topic)
        except Exception:
            pass

    if line.command == 341 and len(line.arguments) == 3: # Inviting
        try:
            i = 0
            inviting_target = decode(line.arguments[i])
            i += 1
            inviting_channel = decode(line.arguments[i])
            i += 1
            inviting_nick = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return Inviting(source=source, target=inviting_target, channel=inviting_channel, nick=inviting_nick)
        except Exception:
            pass

    if line.command == 342 and len(line.arguments) == 3: # Summoning
        try:
            i = 0
            summoning_target = decode(line.arguments[i])
            i += 1
            summoning_user = decode(line.arguments[i])
            i += 1
            # summoning_line.arguments[i]: 'Summoning user to IRC'
            i += 1
            assert i == len(line.arguments)
            return Summoning(source=source, target=summoning_target, user=summoning_user)
        except Exception:
            pass

    if line.command == 346 and len(line.arguments) == 3: # InviteList
        try:
            i = 0
            invite_list_target = decode(line.arguments[i])
            i += 1
            invite_list_channel = decode(line.arguments[i])
            i += 1
            invite_list_mask = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return InviteList(source=source, target=invite_list_target, channel=invite_list_channel, mask=invite_list_mask)
        except Exception:
            pass

    if line.command == 347 and len(line.arguments) == 3: # InviteListEnd
        try:
            i = 0
            invite_list_end_target = decode(line.arguments[i])
            i += 1
            invite_list_end_channel = decode(line.arguments[i])
            i += 1
            # invite_list_end_line.arguments[i]: 'End of channel invite list'
            i += 1
            assert i == len(line.arguments)
            return InviteListEnd(source=source, target=invite_list_end_target, channel=invite_list_end_channel)
        except Exception:
            pass

    if line.command == 348 and len(line.arguments) == 3: # ExceptList
        try:
            i = 0
            except_list_target = decode(line.arguments[i])
            i += 1
            except_list_channel = decode(line.arguments[i])
            i += 1
            except_list_mask = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return ExceptList(source=source, target=except_list_target, channel=except_list_channel, mask=except_list_mask)
        except Exception:
            pass

    if line.command == 349 and len(line.arguments) == 3: # ExceptListEnd
        try:
            i = 0
            except_list_end_target = decode(line.arguments[i])
            i += 1
            except_list_end_channel = decode(line.arguments[i])
            i += 1
            # except_list_end_line.arguments[i]: 'End of channel exception list'
            i += 1
            assert i == len(line.arguments)
            return ExceptListEnd(source=source, target=except_list_end_target, channel=except_list_end_channel)
        except Exception:
            pass

    if line.command == 351 and len(line.arguments) == 4: # VersionReply
        try:
            i = 0
            version_reply_target = decode(line.arguments[i])
            i += 1
            version_reply_version = decode(line.arguments[i])
            i += 1
            version_reply_server = decode(line.arguments[i])
            i += 1
            version_reply_comments = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return VersionReply(source=source, target=version_reply_target, version=version_reply_version, server=version_reply_server, comments=version_reply_comments)
        except Exception:
            pass

    if line.command == 352 and len(line.arguments) == 8: # WhoReply
        try:
            i = 0
            who_reply_target = decode(line.arguments[i])
            i += 1
            who_reply_channel = decode(line.arguments[i])
            i += 1
            who_reply_user = decode(line.arguments[i])
            i += 1
            who_reply_host = decode(line.arguments[i])
            i += 1
            who_reply_server = decode(line.arguments[i])
            i += 1
            who_reply_nickname = decode(line.arguments[i])
            i += 1
            who_reply_props = decode(line.arguments[i])
            i += 1
            who_reply_realname = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return WhoReply(source=source, target=who_reply_target, channel=who_reply_channel, user=who_reply_user, host=who_reply_host, server=who_reply_server, nickname=who_reply_nickname, props=who_reply_props, realname=who_reply_realname)
        except Exception:
            pass

    if line.command == 353 and len(line.arguments) == 4: # NamesReply
        try:
            i = 0
            names_reply_target = decode(line.arguments[i])
            i += 1
            names_reply_mode = decode(line.arguments[i])
            i += 1
            names_reply_channel = decode(line.arguments[i])
            i += 1
            names_reply_nicknames = [decode(x) for x in line.arguments[i].split()]
            i += 1
            assert i == len(line.arguments)
            return NamesReply(source=source, target=names_reply_target, mode=names_reply_mode, channel=names_reply_channel, nicknames=names_reply_nicknames)
        except Exception:
            pass

    if line.command == 364 and len(line.arguments) == 4: # LinksReply
        try:
            i = 0
            links_reply_target = decode(line.arguments[i])
            i += 1
            links_reply_mask = decode(line.arguments[i])
            i += 1
            links_reply_server = decode(line.arguments[i])
            i += 1
            links_reply_info = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return LinksReply(source=source, target=links_reply_target, mask=links_reply_mask, server=links_reply_server, info=links_reply_info)
        except Exception:
            pass

    if line.command == 365 and len(line.arguments) == 3: # LinksEnd
        try:
            i = 0
            links_end_target = decode(line.arguments[i])
            i += 1
            links_end_mask = decode(line.arguments[i])
            i += 1
            # links_end_line.arguments[i]: 'End of LINKS list'
            i += 1
            assert i == len(line.arguments)
            return LinksEnd(source=source, target=links_end_target, mask=links_end_mask)
        except Exception:
            pass

    if line.command == 366 and len(line.arguments) == 3: # NamesEnd
        try:
            i = 0
            names_end_target = decode(line.arguments[i])
            i += 1
            names_end_channel = decode(line.arguments[i])
            i += 1
            # names_end_line.arguments[i]: 'End of NAMES list'
            i += 1
            assert i == len(line.arguments)
            return NamesEnd(source=source, target=names_end_target, channel=names_end_channel)
        except Exception:
            pass

    if line.command == 367 and len(line.arguments) == 3: # BanList
        try:
            i = 0
            ban_list_target = decode(line.arguments[i])
            i += 1
            ban_list_channel = decode(line.arguments[i])
            i += 1
            ban_list_mask = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return BanList(source=source, target=ban_list_target, channel=ban_list_channel, mask=ban_list_mask)
        except Exception:
            pass

    if line.command == 368 and len(line.arguments) == 3: # BanListEnd
        try:
            i = 0
            ban_list_end_target = decode(line.arguments[i])
            i += 1
            ban_list_end_channel = decode(line.arguments[i])
            i += 1
            # ban_list_end_line.arguments[i]: 'End of channel ban list'
            i += 1
            assert i == len(line.arguments)
            return BanListEnd(source=source, target=ban_list_end_target, channel=ban_list_end_channel)
        except Exception:
            pass

    if line.command == 369 and len(line.arguments) == 3: # WhoWasEnd
        try:
            i = 0
            who_was_end_target = decode(line.arguments[i])
            i += 1
            who_was_end_nickname = decode(line.arguments[i])
            i += 1
            # who_was_end_line.arguments[i]: 'End of WHOWAS'
            i += 1
            assert i == len(line.arguments)
            return WhoWasEnd(source=source, target=who_was_end_target, nickname=who_was_end_nickname)
        except Exception:
            pass

    if line.command == 371 and len(line.arguments) == 2: # InfoReply
        try:
            i = 0
            info_reply_target = decode(line.arguments[i])
            i += 1
            info_reply_info = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return InfoReply(source=source, target=info_reply_target, info=info_reply_info)
        except Exception:
            pass

    if line.command == 372 and len(line.arguments) == 2: # MotdText
        try:
            i = 0
            motd_text_target = decode(line.arguments[i])
            i += 1
            motd_text_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return MotdText(source=source, target=motd_text_target, message=motd_text_message)
        except Exception:
            pass

    if line.command == 374 and len(line.arguments) == 2: # InfoEnd
        try:
            i = 0
            info_end_target = decode(line.arguments[i])
            i += 1
            # info_end_line.arguments[i]: 'End of INFO list'
            i += 1
            assert i == len(line.arguments)
            return InfoEnd(source=source, target=info_end_target)
        except Exception:
            pass

    if line.command == 375 and len(line.arguments) == 2: # MotdStart
        try:
            i = 0
            motd_start_target = decode(line.arguments[i])
            i += 1
            motd_start_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return MotdStart(source=source, target=motd_start_target, message=motd_start_message)
        except Exception:
            pass

    if line.command == 376 and len(line.arguments) == 2: # MotdEnd
        try:
            i = 0
            motd_end_target = decode(line.arguments[i])
            i += 1
            # motd_end_line.arguments[i]: 'End of MOTD command'
            i += 1
            assert i == len(line.arguments)
            return MotdEnd(source=source, target=motd_end_target)
        except Exception:
            pass

    if line.command == 381 and len(line.arguments) == 2: # YoureOper
        try:
            i = 0
            youre_oper_target = decode(line.arguments[i])
            i += 1
            # youre_oper_line.arguments[i]: 'You are now an IRC operator'
            i += 1
            assert i == len(line.arguments)
            return YoureOper(source=source, target=youre_oper_target)
        except Exception:
            pass

    if line.command == 382 and len(line.arguments) == 3: # Rehashing
        try:
            i = 0
            rehashing_target = decode(line.arguments[i])
            i += 1
            rehashing_file = decode(line.arguments[i])
            i += 1
            # rehashing_line.arguments[i]: 'Rehashing'
            i += 1
            assert i == len(line.arguments)
            return Rehashing(source=source, target=rehashing_target, file=rehashing_file)
        except Exception:
            pass

    if line.command == 383 and len(line.arguments) == 2: # YoureService
        try:
            i = 0
            youre_service_target = decode(line.arguments[i])
            i += 1
            youre_service_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return YoureService(source=source, target=youre_service_target, message=youre_service_message)
        except Exception:
            pass

    if line.command == 391 and len(line.arguments) == 3: # TimeReply
        try:
            i = 0
            time_reply_target = decode(line.arguments[i])
            i += 1
            time_reply_server = decode(line.arguments[i])
            i += 1
            time_reply_time = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TimeReply(source=source, target=time_reply_target, server=time_reply_server, time=time_reply_time)
        except Exception:
            pass

    if line.command == 392 and len(line.arguments) == 2: # UsersStart
        try:
            i = 0
            users_start_target = decode(line.arguments[i])
            i += 1
            # users_start_line.arguments[i]: 'UserID   Terminal  Host'
            i += 1
            assert i == len(line.arguments)
            return UsersStart(source=source, target=users_start_target)
        except Exception:
            pass

    if line.command == 393 and len(line.arguments) == 2: # UsersReply
        try:
            i = 0
            users_reply_target = decode(line.arguments[i])
            i += 1
            users_reply_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return UsersReply(source=source, target=users_reply_target, message=users_reply_message)
        except Exception:
            pass

    if line.command == 394 and len(line.arguments) == 2: # UsersEnd
        try:
            i = 0
            users_end_target = decode(line.arguments[i])
            i += 1
            # users_end_line.arguments[i]: 'End of users'
            i += 1
            assert i == len(line.arguments)
            return UsersEnd(source=source, target=users_end_target)
        except Exception:
            pass

    if line.command == 395 and len(line.arguments) == 2: # NoUsers
        try:
            i = 0
            no_users_target = decode(line.arguments[i])
            i += 1
            # no_users_line.arguments[i]: 'Nobody logged in'
            i += 1
            assert i == len(line.arguments)
            return NoUsers(source=source, target=no_users_target)
        except Exception:
            pass

    if line.command == 401 and len(line.arguments) == 3: # NoSuchNick
        try:
            i = 0
            no_such_nick_target = decode(line.arguments[i])
            i += 1
            no_such_nick_nickname = decode(line.arguments[i])
            i += 1
            # no_such_nick_line.arguments[i]: 'No such nick/channel'
            i += 1
            assert i == len(line.arguments)
            return NoSuchNick(source=source, target=no_such_nick_target, nickname=no_such_nick_nickname)
        except Exception:
            pass

    if line.command == 402 and len(line.arguments) == 3: # NoSuchServer
        try:
            i = 0
            no_such_server_target = decode(line.arguments[i])
            i += 1
            no_such_server_server = decode(line.arguments[i])
            i += 1
            # no_such_server_line.arguments[i]: 'No such server'
            i += 1
            assert i == len(line.arguments)
            return NoSuchServer(source=source, target=no_such_server_target, server=no_such_server_server)
        except Exception:
            pass

    if line.command == 403 and len(line.arguments) == 3: # NoSuchChannel
        try:
            i = 0
            no_such_channel_target = decode(line.arguments[i])
            i += 1
            no_such_channel_channel = decode(line.arguments[i])
            i += 1
            # no_such_channel_line.arguments[i]: 'No such channel'
            i += 1
            assert i == len(line.arguments)
            return NoSuchChannel(source=source, target=no_such_channel_target, channel=no_such_channel_channel)
        except Exception:
            pass

    if line.command == 404 and len(line.arguments) == 3: # CantSendToChan
        try:
            i = 0
            cant_send_to_chan_target = decode(line.arguments[i])
            i += 1
            cant_send_to_chan_channel = decode(line.arguments[i])
            i += 1
            # cant_send_to_chan_line.arguments[i]: 'Cannot send to channel'
            i += 1
            assert i == len(line.arguments)
            return CantSendToChan(source=source, target=cant_send_to_chan_target, channel=cant_send_to_chan_channel)
        except Exception:
            pass

    if line.command == 405 and len(line.arguments) == 3: # TooManyChannels
        try:
            i = 0
            too_many_channels_target = decode(line.arguments[i])
            i += 1
            too_many_channels_channel = decode(line.arguments[i])
            i += 1
            # too_many_channels_line.arguments[i]: 'You have joined too many channels'
            i += 1
            assert i == len(line.arguments)
            return TooManyChannels(source=source, target=too_many_channels_target, channel=too_many_channels_channel)
        except Exception:
            pass

    if line.command == 406 and len(line.arguments) == 3: # WasNoSuchNick
        try:
            i = 0
            was_no_such_nick_target = decode(line.arguments[i])
            i += 1
            was_no_such_nick_nickname = decode(line.arguments[i])
            i += 1
            # was_no_such_nick_line.arguments[i]: 'There was no such nickname'
            i += 1
            assert i == len(line.arguments)
            return WasNoSuchNick(source=source, target=was_no_such_nick_target, nickname=was_no_such_nick_nickname)
        except Exception:
            pass

    if line.command == 407 and len(line.arguments) == 3: # TooManyTargets
        try:
            i = 0
            too_many_targets_target = decode(line.arguments[i])
            i += 1
            too_many_targets_orig_target = decode(line.arguments[i])
            i += 1
            too_many_targets_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return TooManyTargets(source=source, target=too_many_targets_target, orig_target=too_many_targets_orig_target, message=too_many_targets_message)
        except Exception:
            pass

    if line.command == 408 and len(line.arguments) == 3: # NoSuchService
        try:
            i = 0
            no_such_service_target = decode(line.arguments[i])
            i += 1
            no_such_service_name = decode(line.arguments[i])
            i += 1
            # no_such_service_line.arguments[i]: 'No such service'
            i += 1
            assert i == len(line.arguments)
            return NoSuchService(source=source, target=no_such_service_target, name=no_such_service_name)
        except Exception:
            pass

    if line.command == 409 and len(line.arguments) == 2: # NoOrigin
        try:
            i = 0
            no_origin_target = decode(line.arguments[i])
            i += 1
            # no_origin_line.arguments[i]: 'No origin specified'
            i += 1
            assert i == len(line.arguments)
            return NoOrigin(source=source, target=no_origin_target)
        except Exception:
            pass

    if line.command == 411 and len(line.arguments) == 2: # NoRecipient
        try:
            i = 0
            no_recipient_target = decode(line.arguments[i])
            i += 1
            # no_recipient_line.arguments[i]: 'No recipient given'
            i += 1
            assert i == len(line.arguments)
            return NoRecipient(source=source, target=no_recipient_target)
        except Exception:
            pass

    if line.command == 412 and len(line.arguments) == 2: # NoTextToSend
        try:
            i = 0
            no_text_to_send_target = decode(line.arguments[i])
            i += 1
            # no_text_to_send_line.arguments[i]: 'No text to send'
            i += 1
            assert i == len(line.arguments)
            return NoTextToSend(source=source, target=no_text_to_send_target)
        except Exception:
            pass

    if line.command == 413 and len(line.arguments) == 3: # NoTopLevel
        try:
            i = 0
            no_top_level_target = decode(line.arguments[i])
            i += 1
            no_top_level_mask = decode(line.arguments[i])
            i += 1
            # no_top_level_line.arguments[i]: 'No toplevel domain specified'
            i += 1
            assert i == len(line.arguments)
            return NoTopLevel(source=source, target=no_top_level_target, mask=no_top_level_mask)
        except Exception:
            pass

    if line.command == 414 and len(line.arguments) == 3: # WildTopLevel
        try:
            i = 0
            wild_top_level_target = decode(line.arguments[i])
            i += 1
            wild_top_level_mask = decode(line.arguments[i])
            i += 1
            # wild_top_level_line.arguments[i]: 'Wildcard in toplevel domain'
            i += 1
            assert i == len(line.arguments)
            return WildTopLevel(source=source, target=wild_top_level_target, mask=wild_top_level_mask)
        except Exception:
            pass

    if line.command == 415 and len(line.arguments) == 3: # BadMask
        try:
            i = 0
            bad_mask_target = decode(line.arguments[i])
            i += 1
            bad_mask_mask = decode(line.arguments[i])
            i += 1
            # bad_mask_line.arguments[i]: 'Bad Server/host mask'
            i += 1
            assert i == len(line.arguments)
            return BadMask(source=source, target=bad_mask_target, mask=bad_mask_mask)
        except Exception:
            pass

    if line.command == 421 and len(line.arguments) == 3: # UnknownCommand
        try:
            i = 0
            unknown_command_target = decode(line.arguments[i])
            i += 1
            unknown_command_command = decode(line.arguments[i])
            i += 1
            # unknown_command_line.arguments[i]: 'Unknown command'
            i += 1
            assert i == len(line.arguments)
            return UnknownCommand(source=source, target=unknown_command_target, command=unknown_command_command)
        except Exception:
            pass

    if line.command == 422 and len(line.arguments) == 2: # NoMotd
        try:
            i = 0
            no_motd_target = decode(line.arguments[i])
            i += 1
            # no_motd_line.arguments[i]: 'MOTD File is missing'
            i += 1
            assert i == len(line.arguments)
            return NoMotd(source=source, target=no_motd_target)
        except Exception:
            pass

    if line.command == 423 and len(line.arguments) == 3: # NoAdminInfo
        try:
            i = 0
            no_admin_info_target = decode(line.arguments[i])
            i += 1
            no_admin_info_server = decode(line.arguments[i])
            i += 1
            # no_admin_info_line.arguments[i]: 'No administrative info available'
            i += 1
            assert i == len(line.arguments)
            return NoAdminInfo(source=source, target=no_admin_info_target, server=no_admin_info_server)
        except Exception:
            pass

    if line.command == 424 and len(line.arguments) == 2: # FileError
        try:
            i = 0
            file_error_target = decode(line.arguments[i])
            i += 1
            file_error_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return FileError(source=source, target=file_error_target, message=file_error_message)
        except Exception:
            pass

    if line.command == 431 and len(line.arguments) == 2: # NoNicknameGiven
        try:
            i = 0
            no_nickname_given_target = decode(line.arguments[i])
            i += 1
            # no_nickname_given_line.arguments[i]: 'No nickname given'
            i += 1
            assert i == len(line.arguments)
            return NoNicknameGiven(source=source, target=no_nickname_given_target)
        except Exception:
            pass

    if line.command == 432 and len(line.arguments) == 3: # ErroneusNickname
        try:
            i = 0
            erroneus_nickname_target = decode(line.arguments[i])
            i += 1
            erroneus_nickname_nickname = decode(line.arguments[i])
            i += 1
            # erroneus_nickname_line.arguments[i]: 'Erroneous nickname'
            i += 1
            assert i == len(line.arguments)
            return ErroneusNickname(source=source, target=erroneus_nickname_target, nickname=erroneus_nickname_nickname)
        except Exception:
            pass

    if line.command == 433 and len(line.arguments) == 3: # NicknameInUse
        try:
            i = 0
            nickname_in_use_target = decode(line.arguments[i])
            i += 1
            nickname_in_use_nickname = decode(line.arguments[i])
            i += 1
            # nickname_in_use_line.arguments[i]: 'Nickname is already in use'
            i += 1
            assert i == len(line.arguments)
            return NicknameInUse(source=source, target=nickname_in_use_target, nickname=nickname_in_use_nickname)
        except Exception:
            pass

    if line.command == 436 and len(line.arguments) == 3: # NickCollision
        try:
            i = 0
            nick_collision_target = decode(line.arguments[i])
            i += 1
            nick_collision_nickname = decode(line.arguments[i])
            i += 1
            nick_collision_message = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return NickCollision(source=source, target=nick_collision_target, nickname=nick_collision_nickname, message=nick_collision_message)
        except Exception:
            pass

    if line.command == 437 and len(line.arguments) == 3: # UnavailResource
        try:
            i = 0
            unavail_resource_target = decode(line.arguments[i])
            i += 1
            unavail_resource_name = decode(line.arguments[i])
            i += 1
            # unavail_resource_line.arguments[i]: 'Nick/channel is temporarily unavailable'
            i += 1
            assert i == len(line.arguments)
            return UnavailResource(source=source, target=unavail_resource_target, name=unavail_resource_name)
        except Exception:
            pass

    if line.command == 441 and len(line.arguments) == 4: # UserNotInChannel
        try:
            i = 0
            user_not_in_channel_target = decode(line.arguments[i])
            i += 1
            user_not_in_channel_nickname = decode(line.arguments[i])
            i += 1
            user_not_in_channel_channel = decode(line.arguments[i])
            i += 1
            # user_not_in_channel_line.arguments[i]: "They aren't on that channel"
            i += 1
            assert i == len(line.arguments)
            return UserNotInChannel(source=source, target=user_not_in_channel_target, nickname=user_not_in_channel_nickname, channel=user_not_in_channel_channel)
        except Exception:
            pass

    if line.command == 442 and len(line.arguments) == 3: # NotOnChannel
        try:
            i = 0
            not_on_channel_target = decode(line.arguments[i])
            i += 1
            not_on_channel_channel = decode(line.arguments[i])
            i += 1
            # not_on_channel_line.arguments[i]: "You're not on that channel"
            i += 1
            assert i == len(line.arguments)
            return NotOnChannel(source=source, target=not_on_channel_target, channel=not_on_channel_channel)
        except Exception:
            pass

    if line.command == 443 and len(line.arguments) == 4: # UserOnChannel
        try:
            i = 0
            user_on_channel_target = decode(line.arguments[i])
            i += 1
            user_on_channel_user = decode(line.arguments[i])
            i += 1
            user_on_channel_channel = decode(line.arguments[i])
            i += 1
            # user_on_channel_line.arguments[i]: 'is already on channel'
            i += 1
            assert i == len(line.arguments)
            return UserOnChannel(source=source, target=user_on_channel_target, user=user_on_channel_user, channel=user_on_channel_channel)
        except Exception:
            pass

    if line.command == 444 and len(line.arguments) == 3: # NoLogin
        try:
            i = 0
            no_login_target = decode(line.arguments[i])
            i += 1
            no_login_user = decode(line.arguments[i])
            i += 1
            # no_login_line.arguments[i]: 'User not logged in'
            i += 1
            assert i == len(line.arguments)
            return NoLogin(source=source, target=no_login_target, user=no_login_user)
        except Exception:
            pass

    if line.command == 445 and len(line.arguments) == 2: # SummonDisabled
        try:
            i = 0
            summon_disabled_target = decode(line.arguments[i])
            i += 1
            # summon_disabled_line.arguments[i]: 'SUMMON has been disabled'
            i += 1
            assert i == len(line.arguments)
            return SummonDisabled(source=source, target=summon_disabled_target)
        except Exception:
            pass

    if line.command == 446 and len(line.arguments) == 2: # UsersDisabled
        try:
            i = 0
            users_disabled_target = decode(line.arguments[i])
            i += 1
            # users_disabled_line.arguments[i]: 'USERS has been disabled'
            i += 1
            assert i == len(line.arguments)
            return UsersDisabled(source=source, target=users_disabled_target)
        except Exception:
            pass

    if line.command == 451 and len(line.arguments) == 2: # NotRegistered
        try:
            i = 0
            not_registered_target = decode(line.arguments[i])
            i += 1
            # not_registered_line.arguments[i]: 'You have not registered'
            i += 1
            assert i == len(line.arguments)
            return NotRegistered(source=source, target=not_registered_target)
        except Exception:
            pass

    if line.command == 461 and len(line.arguments) == 3: # NeedMoreParams
        try:
            i = 0
            need_more_params_target = decode(line.arguments[i])
            i += 1
            need_more_params_command = decode(line.arguments[i])
            i += 1
            # need_more_params_line.arguments[i]: 'Not enough parameters'
            i += 1
            assert i == len(line.arguments)
            return NeedMoreParams(source=source, target=need_more_params_target, command=need_more_params_command)
        except Exception:
            pass

    if line.command == 462 and len(line.arguments) == 2: # AlreadyRegistered
        try:
            i = 0
            already_registered_target = decode(line.arguments[i])
            i += 1
            # already_registered_line.arguments[i]: 'Unauthorized command (already registered)'
            i += 1
            assert i == len(line.arguments)
            return AlreadyRegistered(source=source, target=already_registered_target)
        except Exception:
            pass

    if line.command == 463 and len(line.arguments) == 2: # NoPermForHost
        try:
            i = 0
            no_perm_for_host_target = decode(line.arguments[i])
            i += 1
            # no_perm_for_host_line.arguments[i]: "Your host isn't among the privileged"
            i += 1
            assert i == len(line.arguments)
            return NoPermForHost(source=source, target=no_perm_for_host_target)
        except Exception:
            pass

    if line.command == 464 and len(line.arguments) == 2: # PasswordMismatch
        try:
            i = 0
            password_mismatch_target = decode(line.arguments[i])
            i += 1
            # password_mismatch_line.arguments[i]: 'Password incorrect'
            i += 1
            assert i == len(line.arguments)
            return PasswordMismatch(source=source, target=password_mismatch_target)
        except Exception:
            pass

    if line.command == 465 and len(line.arguments) == 2: # YoureBannedCreep
        try:
            i = 0
            youre_banned_creep_target = decode(line.arguments[i])
            i += 1
            # youre_banned_creep_line.arguments[i]: 'You are banned from this server'
            i += 1
            assert i == len(line.arguments)
            return YoureBannedCreep(source=source, target=youre_banned_creep_target)
        except Exception:
            pass

    if line.command == 466 and len(line.arguments) == 1: # YouWillBeBanned
        try:
            i = 0
            you_will_be_banned_target = decode(line.arguments[i])
            i += 1
            assert i == len(line.arguments)
            return YouWillBeBanned(source=source, target=you_will_be_banned_target)
        except Exception:
            pass

    if line.command == 467 and len(line.arguments) == 3: # KeySet
        try:
            i = 0
            key_set_target = decode(line.arguments[i])
            i += 1
            key_set_channel = decode(line.arguments[i])
            i += 1
            # key_set_line.arguments[i]: 'Channel key already set'
            i += 1
            assert i == len(line.arguments)
            return KeySet(source=source, target=key_set_target, channel=key_set_channel)
        except Exception:
            pass

    if line.command == 471 and len(line.arguments) == 3: # ChannelIsFull
        try:
            i = 0
            channel_is_full_target = decode(line.arguments[i])
            i += 1
            channel_is_full_channel = decode(line.arguments[i])
            i += 1
            # channel_is_full_line.arguments[i]: 'Cannot join channel (+l)'
            i += 1
            assert i == len(line.arguments)
            return ChannelIsFull(source=source, target=channel_is_full_target, channel=channel_is_full_channel)
        except Exception:
            pass

    if line.command == 472 and len(line.arguments) == 3: # UnknownMode
        try:
            i = 0
            unknown_mode_target = decode(line.arguments[i])
            i += 1
            unknown_mode_char = decode(line.arguments[i])
            i += 1
            # unknown_mode_line.arguments[i]: 'is unknown mode char to me'
            i += 1
            assert i == len(line.arguments)
            return UnknownMode(source=source, target=unknown_mode_target, char=unknown_mode_char)
        except Exception:
            pass

    if line.command == 473 and len(line.arguments) == 3: # InviteOnlyChan
        try:
            i = 0
            invite_only_chan_target = decode(line.arguments[i])
            i += 1
            invite_only_chan_channel = decode(line.arguments[i])
            i += 1
            # invite_only_chan_line.arguments[i]: 'Cannot join channel (+i)'
            i += 1
            assert i == len(line.arguments)
            return InviteOnlyChan(source=source, target=invite_only_chan_target, channel=invite_only_chan_channel)
        except Exception:
            pass

    if line.command == 474 and len(line.arguments) == 3: # BannedFromChan
        try:
            i = 0
            banned_from_chan_target = decode(line.arguments[i])
            i += 1
            banned_from_chan_channel = decode(line.arguments[i])
            i += 1
            # banned_from_chan_line.arguments[i]: 'Cannot join channel (+b)'
            i += 1
            assert i == len(line.arguments)
            return BannedFromChan(source=source, target=banned_from_chan_target, channel=banned_from_chan_channel)
        except Exception:
            pass

    if line.command == 475 and len(line.arguments) == 3: # BadChannelKey
        try:
            i = 0
            bad_channel_key_target = decode(line.arguments[i])
            i += 1
            bad_channel_key_channel = decode(line.arguments[i])
            i += 1
            # bad_channel_key_line.arguments[i]: 'Cannot join channel (+k)'
            i += 1
            assert i == len(line.arguments)
            return BadChannelKey(source=source, target=bad_channel_key_target, channel=bad_channel_key_channel)
        except Exception:
            pass

    if line.command == 476 and len(line.arguments) == 3: # BadChanMask
        try:
            i = 0
            bad_chan_mask_target = decode(line.arguments[i])
            i += 1
            bad_chan_mask_channel = decode(line.arguments[i])
            i += 1
            # bad_chan_mask_line.arguments[i]: 'Bad Channel Mask'
            i += 1
            assert i == len(line.arguments)
            return BadChanMask(source=source, target=bad_chan_mask_target, channel=bad_chan_mask_channel)
        except Exception:
            pass

    if line.command == 477 and len(line.arguments) == 3: # NoChanModes
        try:
            i = 0
            no_chan_modes_target = decode(line.arguments[i])
            i += 1
            no_chan_modes_channel = decode(line.arguments[i])
            i += 1
            # no_chan_modes_line.arguments[i]: "Channel doesn't support modes"
            i += 1
            assert i == len(line.arguments)
            return NoChanModes(source=source, target=no_chan_modes_target, channel=no_chan_modes_channel)
        except Exception:
            pass

    if line.command == 478 and len(line.arguments) == 4: # BanListFull
        try:
            i = 0
            ban_list_full_target = decode(line.arguments[i])
            i += 1
            ban_list_full_channel = decode(line.arguments[i])
            i += 1
            ban_list_full_char = decode(line.arguments[i])
            i += 1
            # ban_list_full_line.arguments[i]: 'Channel list is full'
            i += 1
            assert i == len(line.arguments)
            return BanListFull(source=source, target=ban_list_full_target, channel=ban_list_full_channel, char=ban_list_full_char)
        except Exception:
            pass

    if line.command == 481 and len(line.arguments) == 2: # NoPrivileges
        try:
            i = 0
            no_privileges_target = decode(line.arguments[i])
            i += 1
            # no_privileges_line.arguments[i]: "Permission Denied- You're not an IRC operator"
            i += 1
            assert i == len(line.arguments)
            return NoPrivileges(source=source, target=no_privileges_target)
        except Exception:
            pass

    if line.command == 482 and len(line.arguments) == 3: # ChanOpPrivsNeeded
        try:
            i = 0
            chan_op_privs_needed_target = decode(line.arguments[i])
            i += 1
            chan_op_privs_needed_channel = decode(line.arguments[i])
            i += 1
            # chan_op_privs_needed_line.arguments[i]: "You're not channel operator"
            i += 1
            assert i == len(line.arguments)
            return ChanOpPrivsNeeded(source=source, target=chan_op_privs_needed_target, channel=chan_op_privs_needed_channel)
        except Exception:
            pass

    if line.command == 483 and len(line.arguments) == 2: # CantKillServer
        try:
            i = 0
            cant_kill_server_target = decode(line.arguments[i])
            i += 1
            # cant_kill_server_line.arguments[i]: "You can't kill a server!"
            i += 1
            assert i == len(line.arguments)
            return CantKillServer(source=source, target=cant_kill_server_target)
        except Exception:
            pass

    if line.command == 484 and len(line.arguments) == 2: # Restricted
        try:
            i = 0
            restricted_target = decode(line.arguments[i])
            i += 1
            # restricted_line.arguments[i]: 'Your connection is restricted!'
            i += 1
            assert i == len(line.arguments)
            return Restricted(source=source, target=restricted_target)
        except Exception:
            pass

    if line.command == 485 and len(line.arguments) == 2: # UniqOpPrivsNeeded
        try:
            i = 0
            uniq_op_privs_needed_target = decode(line.arguments[i])
            i += 1
            # uniq_op_privs_needed_line.arguments[i]: "You're not the original channel operator"
            i += 1
            assert i == len(line.arguments)
            return UniqOpPrivsNeeded(source=source, target=uniq_op_privs_needed_target)
        except Exception:
            pass

    if line.command == 491 and len(line.arguments) == 2: # NoOperHost
        try:
            i = 0
            no_oper_host_target = decode(line.arguments[i])
            i += 1
            # no_oper_host_line.arguments[i]: 'No O-lines for your host'
            i += 1
            assert i == len(line.arguments)
            return NoOperHost(source=source, target=no_oper_host_target)
        except Exception:
            pass

    if line.command == 501 and len(line.arguments) == 2: # UserModeUnknownFlag
        try:
            i = 0
            user_mode_unknown_flag_target = decode(line.arguments[i])
            i += 1
            # user_mode_unknown_flag_line.arguments[i]: 'Unknown MODE flag'
            i += 1
            assert i == len(line.arguments)
            return UserModeUnknownFlag(source=source, target=user_mode_unknown_flag_target)
        except Exception:
            pass

    if line.command == 502 and len(line.arguments) == 2: # UsersDontMatch
        try:
            i = 0
            users_dont_match_target = decode(line.arguments[i])
            i += 1
            # users_dont_match_line.arguments[i]: 'Cannot change mode for other users'
            i += 1
            assert i == len(line.arguments)
            return UsersDontMatch(source=source, target=users_dont_match_target)
        except Exception:
            pass

    return Unknown(source, line.command, line.arguments)

class Pass(Message):
    """
    ``PASS <password>``
    """

    __slots__ = ['password']

    def __init__(self, source: str, password: str) -> None:
        self.source = source
        self.password = password

    def __repr__(self) -> str:
        return 'Pass(source={}, password={})'.format(repr(self.source), repr(self.password))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.password))
        return Line(source, b'PASS', arguments)


class Nick(Message):
    """
    ``NICK <nickname>``
    """

    __slots__ = ['nickname']

    def __init__(self, source: str, nickname: str) -> None:
        self.source = source
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'Nick(source={}, nickname={})'.format(repr(self.source), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.nickname))
        return Line(source, b'NICK', arguments)


class User(Message):
    """
    ``USER <user> <int:mode> * <realname>``
    """

    __slots__ = ['user', 'mode', 'realname']

    def __init__(self, source: str, user: str, mode: int, realname: str) -> None:
        self.source = source
        self.user = user
        self.mode = mode
        self.realname = realname

    def __repr__(self) -> str:
        return 'User(source={}, user={}, mode={}, realname={})'.format(repr(self.source), repr(self.user), repr(self.mode), repr(self.realname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.user))
        arguments.append(encode(str(self.mode)))
        arguments.append(b'*')
        arguments.append(encode(self.realname))
        return Line(source, b'USER', arguments)


class Oper(Message):
    """
    ``OPER <name> <password>``
    """

    __slots__ = ['name', 'password']

    def __init__(self, source: str, name: str, password: str) -> None:
        self.source = source
        self.name = name
        self.password = password

    def __repr__(self) -> str:
        return 'Oper(source={}, name={}, password={})'.format(repr(self.source), repr(self.name), repr(self.password))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.name))
        arguments.append(encode(self.password))
        return Line(source, b'OPER', arguments)


class Mode(Message):
    """
    ``MODE <name> <mode>``

    FIXME multiples.
    """

    __slots__ = ['name', 'mode']

    def __init__(self, source: str, name: str, mode: str) -> None:
        self.source = source
        self.name = name
        self.mode = mode

    def __repr__(self) -> str:
        return 'Mode(source={}, name={}, mode={})'.format(repr(self.source), repr(self.name), repr(self.mode))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.name))
        arguments.append(encode(self.mode))
        return Line(source, b'MODE', arguments)


class Service(Message):
    """
    ``SERVICE <nickname> * <distribution> <int:type> 0 <info>``
    """

    __slots__ = ['nickname', 'distribution', 'type', 'info']

    def __init__(self, source: str, nickname: str, distribution: str, type: int, info: str) -> None:
        self.source = source
        self.nickname = nickname
        self.distribution = distribution
        self.type = type
        self.info = info

    def __repr__(self) -> str:
        return 'Service(source={}, nickname={}, distribution={}, type={}, info={})'.format(repr(self.source), repr(self.nickname), repr(self.distribution), repr(self.type), repr(self.info))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.nickname))
        arguments.append(b'*')
        arguments.append(encode(self.distribution))
        arguments.append(encode(str(self.type)))
        arguments.append(b'0')
        arguments.append(encode(self.info))
        return Line(source, b'SERVICE', arguments)


class Quit(Message):
    """
    ``QUIT [message]``
    """

    __slots__ = ['message']

    def __init__(self, source: str, message: str = None) -> None:
        self.source = source
        self.message = message

    def __repr__(self) -> str:
        return 'Quit(source={}, message={})'.format(repr(self.source), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.message is not None:
            arguments.append(encode(self.message))
        return Line(source, b'QUIT', arguments)


class SQuit(Message):
    """
    ``SQUIT <server> <comment>``
    """

    __slots__ = ['server', 'comment']

    def __init__(self, source: str, server: str, comment: str) -> None:
        self.source = source
        self.server = server
        self.comment = comment

    def __repr__(self) -> str:
        return 'SQuit(source={}, server={}, comment={})'.format(repr(self.source), repr(self.server), repr(self.comment))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.server))
        arguments.append(encode(self.comment))
        return Line(source, b'SQUIT', arguments)


class ChannelJoin(Message):
    """
    ``JOIN <channels,> [keys,]``
    """

    __slots__ = ['channels', 'keys']

    def __init__(self, source: str, channels: typing.List[str], keys: typing.List[str] = None) -> None:
        self.source = source
        self.channels = channels
        self.keys = keys

    def __repr__(self) -> str:
        return 'ChannelJoin(source={}, channels={}, keys={})'.format(repr(self.source), repr(self.channels), repr(self.keys))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(b",".join(encode(x) for x in self.channels))
        if self.keys is not None:
            arguments.append(b",".join(encode(x) for x in self.keys))
        return Line(source, b'JOIN', arguments)


class ChannelPart(Message):
    """
    ``PART <channels,> [message]``
    """

    __slots__ = ['channels', 'message']

    def __init__(self, source: str, channels: typing.List[str], message: str = None) -> None:
        self.source = source
        self.channels = channels
        self.message = message

    def __repr__(self) -> str:
        return 'ChannelPart(source={}, channels={}, message={})'.format(repr(self.source), repr(self.channels), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(b",".join(encode(x) for x in self.channels))
        if self.message is not None:
            arguments.append(encode(self.message))
        return Line(source, b'PART', arguments)


class Topic(Message):
    """
    ``TOPIC <channel> [topic]``
    """

    __slots__ = ['channel', 'topic']

    def __init__(self, source: str, channel: str, topic: str = None) -> None:
        self.source = source
        self.channel = channel
        self.topic = topic

    def __repr__(self) -> str:
        return 'Topic(source={}, channel={}, topic={})'.format(repr(self.source), repr(self.channel), repr(self.topic))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.channel))
        if self.topic is not None:
            arguments.append(encode(self.topic))
        return Line(source, b'TOPIC', arguments)


class Names(Message):
    """
    ``NAMES [channels,] [target]``
    """

    __slots__ = ['channels', 'target']

    def __init__(self, source: str, channels: typing.List[str] = None, target: str = None) -> None:
        self.source = source
        self.channels = channels
        self.target = target

    def __repr__(self) -> str:
        return 'Names(source={}, channels={}, target={})'.format(repr(self.source), repr(self.channels), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.channels is not None:
            arguments.append(b",".join(encode(x) for x in self.channels))
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'NAMES', arguments)


class List(Message):
    """
    ``LIST [channels,] [target]``
    """

    __slots__ = ['channels', 'target']

    def __init__(self, source: str, channels: typing.List[str] = None, target: str = None) -> None:
        self.source = source
        self.channels = channels
        self.target = target

    def __repr__(self) -> str:
        return 'List(source={}, channels={}, target={})'.format(repr(self.source), repr(self.channels), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.channels is not None:
            arguments.append(b",".join(encode(x) for x in self.channels))
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'LIST', arguments)


class Invite(Message):
    """
    ``INVITE <nickname> <channel>``
    """

    __slots__ = ['nickname', 'channel']

    def __init__(self, source: str, nickname: str, channel: str) -> None:
        self.source = source
        self.nickname = nickname
        self.channel = channel

    def __repr__(self) -> str:
        return 'Invite(source={}, nickname={}, channel={})'.format(repr(self.source), repr(self.nickname), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.channel))
        return Line(source, b'INVITE', arguments)


class Kick(Message):
    """
    ``KICK <channels,> <users,> [comment]``
    """

    __slots__ = ['channels', 'users', 'comment']

    def __init__(self, source: str, channels: typing.List[str], users: typing.List[str], comment: str = None) -> None:
        self.source = source
        self.channels = channels
        self.users = users
        self.comment = comment

    def __repr__(self) -> str:
        return 'Kick(source={}, channels={}, users={}, comment={})'.format(repr(self.source), repr(self.channels), repr(self.users), repr(self.comment))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(b",".join(encode(x) for x in self.channels))
        arguments.append(b",".join(encode(x) for x in self.users))
        if self.comment is not None:
            arguments.append(encode(self.comment))
        return Line(source, b'KICK', arguments)


class Privmsg(Message):
    """
    ``PRIVMSG <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'Privmsg(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b'PRIVMSG', arguments)


class Notice(Message):
    """
    ``NOTICE <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'Notice(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b'NOTICE', arguments)


class Motd(Message):
    """
    ``MOTD [target]``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str = None) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'Motd(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'MOTD', arguments)


class Lusers(Message):
    """
    ``LUSERS [mask] [target]``
    """

    __slots__ = ['mask', 'target']

    def __init__(self, source: str, mask: str = None, target: str = None) -> None:
        self.source = source
        self.mask = mask
        self.target = target

    def __repr__(self) -> str:
        return 'Lusers(source={}, mask={}, target={})'.format(repr(self.source), repr(self.mask), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.mask is not None:
            arguments.append(encode(self.mask))
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'LUSERS', arguments)


class Version(Message):
    """
    ``VERSION [target]``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str = None) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'Version(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'VERSION', arguments)


class Stats(Message):
    """
    ``STATS [query] [target]``
    """

    __slots__ = ['query', 'target']

    def __init__(self, source: str, query: str = None, target: str = None) -> None:
        self.source = source
        self.query = query
        self.target = target

    def __repr__(self) -> str:
        return 'Stats(source={}, query={}, target={})'.format(repr(self.source), repr(self.query), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.query is not None:
            arguments.append(encode(self.query))
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'STATS', arguments)


class Links(Message):
    """
    ``LINKS (server) (mask)``
    """

    __slots__ = ['server', 'mask']

    def __init__(self, source: str, server: str = None, mask: str = None) -> None:
        self.source = source
        self.server = server
        self.mask = mask

    def __repr__(self) -> str:
        return 'Links(source={}, server={}, mask={})'.format(repr(self.source), repr(self.server), repr(self.mask))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.server is not None:
            arguments.append(encode(self.server))
        if self.mask is not None:
            arguments.append(encode(self.mask))
        return Line(source, b'LINKS', arguments)


class Time(Message):
    """
    ``TIME [target]``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str = None) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'Time(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'TIME', arguments)


class ServerConnect(Message):
    """
    ``CONNECT <target> <int:port> [remote]``
    """

    __slots__ = ['target', 'port', 'remote']

    def __init__(self, source: str, target: str, port: int, remote: str = None) -> None:
        self.source = source
        self.target = target
        self.port = port
        self.remote = remote

    def __repr__(self) -> str:
        return 'ServerConnect(source={}, target={}, port={}, remote={})'.format(repr(self.source), repr(self.target), repr(self.port), repr(self.remote))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(str(self.port)))
        if self.remote is not None:
            arguments.append(encode(self.remote))
        return Line(source, b'CONNECT', arguments)


class Trace(Message):
    """
    ``TRACE [target]``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str = None) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'Trace(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'TRACE', arguments)


class Admin(Message):
    """
    ``ADMIN [target]``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str = None) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'Admin(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'ADMIN', arguments)


class Info(Message):
    """
    ``INFO [target]``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str = None) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'Info(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'INFO', arguments)


class ServList(Message):
    """
    ``SERVLIST [mask] [type]``
    """

    __slots__ = ['mask', 'type']

    def __init__(self, source: str, mask: str = None, type: str = None) -> None:
        self.source = source
        self.mask = mask
        self.type = type

    def __repr__(self) -> str:
        return 'ServList(source={}, mask={}, type={})'.format(repr(self.source), repr(self.mask), repr(self.type))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.mask is not None:
            arguments.append(encode(self.mask))
        if self.type is not None:
            arguments.append(encode(self.type))
        return Line(source, b'SERVLIST', arguments)


class SQuery(Message):
    """
    ``SQUERY <servicename> <text>``
    """

    __slots__ = ['servicename', 'text']

    def __init__(self, source: str, servicename: str, text: str) -> None:
        self.source = source
        self.servicename = servicename
        self.text = text

    def __repr__(self) -> str:
        return 'SQuery(source={}, servicename={}, text={})'.format(repr(self.source), repr(self.servicename), repr(self.text))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.servicename))
        arguments.append(encode(self.text))
        return Line(source, b'SQUERY', arguments)


class Who(Message):
    """
    ``WHO [mask] [flag(o):operators]``
    """

    __slots__ = ['mask', 'operators']

    def __init__(self, source: str, mask: str = None, operators: bool = None) -> None:
        self.source = source
        self.mask = mask
        self.operators = operators

    def __repr__(self) -> str:
        return 'Who(source={}, mask={}, operators={})'.format(repr(self.source), repr(self.mask), repr(self.operators))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.mask is not None:
            arguments.append(encode(self.mask))
        if self.operators is not None:
            arguments.append(b'o')
        return Line(source, b'WHO', arguments)


class WhoIs(Message):
    """
    ``WHOIS [target] <masks,>``
    """

    __slots__ = ['target', 'masks']

    def __init__(self, source: str, masks: typing.List[str], target: str = None) -> None:
        self.source = source
        self.target = target
        self.masks = masks

    def __repr__(self) -> str:
        return 'WhoIs(source={}, target={}, masks={})'.format(repr(self.source), repr(self.target), repr(self.masks))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.target is not None:
            arguments.append(encode(self.target))
        arguments.append(b",".join(encode(x) for x in self.masks))
        return Line(source, b'WHOIS', arguments)


class WhoWas(Message):
    """
    ``WHOWAS <nicknames,> [int:count] [target]``
    """

    __slots__ = ['nicknames', 'count', 'target']

    def __init__(self, source: str, nicknames: typing.List[str], count: int = None, target: str = None) -> None:
        self.source = source
        self.nicknames = nicknames
        self.count = count
        self.target = target

    def __repr__(self) -> str:
        return 'WhoWas(source={}, nicknames={}, count={}, target={})'.format(repr(self.source), repr(self.nicknames), repr(self.count), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(b",".join(encode(x) for x in self.nicknames))
        if self.count is not None:
            arguments.append(encode(str(self.count)))
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'WHOWAS', arguments)


class Kill(Message):
    """
    ``KILL <nickname> <comment>``
    """

    __slots__ = ['nickname', 'comment']

    def __init__(self, source: str, nickname: str, comment: str) -> None:
        self.source = source
        self.nickname = nickname
        self.comment = comment

    def __repr__(self) -> str:
        return 'Kill(source={}, nickname={}, comment={})'.format(repr(self.source), repr(self.nickname), repr(self.comment))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.comment))
        return Line(source, b'KILL', arguments)


class Ping(Message):
    """
    ``PING <server1> [server2]``
    """

    __slots__ = ['server1', 'server2']

    def __init__(self, source: str, server1: str, server2: str = None) -> None:
        self.source = source
        self.server1 = server1
        self.server2 = server2

    def __repr__(self) -> str:
        return 'Ping(source={}, server1={}, server2={})'.format(repr(self.source), repr(self.server1), repr(self.server2))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.server1))
        if self.server2 is not None:
            arguments.append(encode(self.server2))
        return Line(source, b'PING', arguments)


class Pong(Message):
    """
    ``PONG <server> [server2]``
    """

    __slots__ = ['server', 'server2']

    def __init__(self, source: str, server: str, server2: str = None) -> None:
        self.source = source
        self.server = server
        self.server2 = server2

    def __repr__(self) -> str:
        return 'Pong(source={}, server={}, server2={})'.format(repr(self.source), repr(self.server), repr(self.server2))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.server))
        if self.server2 is not None:
            arguments.append(encode(self.server2))
        return Line(source, b'PONG', arguments)


class Error(Message):
    """
    ``ERROR <message>``
    """

    __slots__ = ['message']

    def __init__(self, source: str, message: str) -> None:
        self.source = source
        self.message = message

    def __repr__(self) -> str:
        return 'Error(source={}, message={})'.format(repr(self.source), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.message))
        return Line(source, b'ERROR', arguments)


class Away(Message):
    """
    ``AWAY [text]``
    """

    __slots__ = ['text']

    def __init__(self, source: str, text: str = None) -> None:
        self.source = source
        self.text = text

    def __repr__(self) -> str:
        return 'Away(source={}, text={})'.format(repr(self.source), repr(self.text))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.text is not None:
            arguments.append(encode(self.text))
        return Line(source, b'AWAY', arguments)


class Rehash(Message):
    """
    ``REHASH``
    """

    def __init__(self, source: str) -> None:
        self.source = source

    def __repr__(self) -> str:
        return 'Rehash(source={})'.format(repr(self.source))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        return Line(source, b'REHASH')


class Die(Message):
    """
    ``DIE``
    """

    def __init__(self, source: str) -> None:
        self.source = source

    def __repr__(self) -> str:
        return 'Die(source={})'.format(repr(self.source))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        return Line(source, b'DIE')


class Restart(Message):
    """
    ``RESTART``
    """

    def __init__(self, source: str) -> None:
        self.source = source

    def __repr__(self) -> str:
        return 'Restart(source={})'.format(repr(self.source))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        return Line(source, b'RESTART')


class Summon(Message):
    """
    ``SUMMON <user> [target] [channel]``
    """

    __slots__ = ['user', 'target', 'channel']

    def __init__(self, source: str, user: str, target: str = None, channel: str = None) -> None:
        self.source = source
        self.user = user
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'Summon(source={}, user={}, target={}, channel={})'.format(repr(self.source), repr(self.user), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.user))
        if self.target is not None:
            arguments.append(encode(self.target))
        if self.channel is not None:
            arguments.append(encode(self.channel))
        return Line(source, b'SUMMON', arguments)


class Users(Message):
    """
    ``USERS [target]``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str = None) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'Users(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        if self.target is not None:
            arguments.append(encode(self.target))
        return Line(source, b'USERS', arguments)


class WallOps(Message):
    """
    ``WALLOPS <message>``
    """

    __slots__ = ['message']

    def __init__(self, source: str, message: str) -> None:
        self.source = source
        self.message = message

    def __repr__(self) -> str:
        return 'WallOps(source={}, message={})'.format(repr(self.source), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.message))
        return Line(source, b'WALLOPS', arguments)


class UserHost(Message):
    """
    ``USERHOST <nickname>``

    FIXME many nicknames.
    """

    __slots__ = ['nickname']

    def __init__(self, source: str, nickname: str) -> None:
        self.source = source
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'UserHost(source={}, nickname={})'.format(repr(self.source), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.nickname))
        return Line(source, b'USERHOST', arguments)


class IsOn(Message):
    """
    ``ISON <nickname>``

    FIXME many nicknames.
    """

    __slots__ = ['nickname']

    def __init__(self, source: str, nickname: str) -> None:
        self.source = source
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'IsOn(source={}, nickname={})'.format(repr(self.source), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.nickname))
        return Line(source, b'ISON', arguments)


class Welcome(Message):
    """
    ``001 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'Welcome(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"001", arguments)


class YourHost(Message):
    """
    ``002 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'YourHost(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"002", arguments)


class Created(Message):
    """
    ``003 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'Created(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"003", arguments)


class MyInfo(Message):
    """
    ``004 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'MyInfo(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"004", arguments)


class Bounce(Message):
    """
    ``005 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'Bounce(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"005", arguments)


class TraceLinkReply(Message):
    """
    ``200 <target> Link <version> <destination> <next> <protocol-version> <link-uptime> <back-send-q> <up-send-q>``
    """

    __slots__ = ['target', 'version', 'destination', 'next', 'protocol_version', 'link_uptime', 'back_send_q', 'up_send_q']

    def __init__(self, source: str, target: str, version: str, destination: str, next: str, protocol_version: str, link_uptime: str, back_send_q: str, up_send_q: str) -> None:
        self.source = source
        self.target = target
        self.version = version
        self.destination = destination
        self.next = next
        self.protocol_version = protocol_version
        self.link_uptime = link_uptime
        self.back_send_q = back_send_q
        self.up_send_q = up_send_q

    def __repr__(self) -> str:
        return 'TraceLinkReply(source={}, target={}, version={}, destination={}, next={}, protocol_version={}, link_uptime={}, back_send_q={}, up_send_q={})'.format(repr(self.source), repr(self.target), repr(self.version), repr(self.destination), repr(self.next), repr(self.protocol_version), repr(self.link_uptime), repr(self.back_send_q), repr(self.up_send_q))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Link')
        arguments.append(encode(self.version))
        arguments.append(encode(self.destination))
        arguments.append(encode(self.next))
        arguments.append(encode(self.protocol_version))
        arguments.append(encode(self.link_uptime))
        arguments.append(encode(self.back_send_q))
        arguments.append(encode(self.up_send_q))
        return Line(source, b"200", arguments)


class TraceConnecting(Message):
    """
    ``201 <target> Try. <class> <server>``
    """

    __slots__ = ['target', 'cls', 'server']

    def __init__(self, source: str, target: str, cls: str, server: str) -> None:
        self.source = source
        self.target = target
        self.cls = cls
        self.server = server

    def __repr__(self) -> str:
        return 'TraceConnecting(source={}, target={}, cls={}, server={})'.format(repr(self.source), repr(self.target), repr(self.cls), repr(self.server))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Try.')
        arguments.append(encode(self.cls))
        arguments.append(encode(self.server))
        return Line(source, b"201", arguments)


class TraceHandshake(Message):
    """
    ``202 <target> H.S. <class> <server>``
    """

    __slots__ = ['target', 'cls', 'server']

    def __init__(self, source: str, target: str, cls: str, server: str) -> None:
        self.source = source
        self.target = target
        self.cls = cls
        self.server = server

    def __repr__(self) -> str:
        return 'TraceHandshake(source={}, target={}, cls={}, server={})'.format(repr(self.source), repr(self.target), repr(self.cls), repr(self.server))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'H.S.')
        arguments.append(encode(self.cls))
        arguments.append(encode(self.server))
        return Line(source, b"202", arguments)


class TraceUnknown(Message):
    """
    ``203 <target> ???? <class> [ip]``
    """

    __slots__ = ['target', 'cls', 'ip']

    def __init__(self, source: str, target: str, cls: str, ip: str = None) -> None:
        self.source = source
        self.target = target
        self.cls = cls
        self.ip = ip

    def __repr__(self) -> str:
        return 'TraceUnknown(source={}, target={}, cls={}, ip={})'.format(repr(self.source), repr(self.target), repr(self.cls), repr(self.ip))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'????')
        arguments.append(encode(self.cls))
        if self.ip is not None:
            arguments.append(encode(self.ip))
        return Line(source, b"203", arguments)


class TraceOperator(Message):
    """
    ``204 <target> Oper <class> <nickname>``
    """

    __slots__ = ['target', 'cls', 'nickname']

    def __init__(self, source: str, target: str, cls: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.cls = cls
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'TraceOperator(source={}, target={}, cls={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.cls), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Oper')
        arguments.append(encode(self.cls))
        arguments.append(encode(self.nickname))
        return Line(source, b"204", arguments)


class TraceUser(Message):
    """
    ``205 <target> User <class> <nickname>``
    """

    __slots__ = ['target', 'cls', 'nickname']

    def __init__(self, source: str, target: str, cls: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.cls = cls
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'TraceUser(source={}, target={}, cls={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.cls), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'User')
        arguments.append(encode(self.cls))
        arguments.append(encode(self.nickname))
        return Line(source, b"205", arguments)


class TraceServer(Message):
    """
    ``206 <target> Serv <class> <s> <c> <server> <hostmask> <protocol-version>``
    """

    __slots__ = ['target', 'cls', 's', 'c', 'server', 'hostmask', 'protocol_version']

    def __init__(self, source: str, target: str, cls: str, s: str, c: str, server: str, hostmask: str, protocol_version: str) -> None:
        self.source = source
        self.target = target
        self.cls = cls
        self.s = s
        self.c = c
        self.server = server
        self.hostmask = hostmask
        self.protocol_version = protocol_version

    def __repr__(self) -> str:
        return 'TraceServer(source={}, target={}, cls={}, s={}, c={}, server={}, hostmask={}, protocol_version={})'.format(repr(self.source), repr(self.target), repr(self.cls), repr(self.s), repr(self.c), repr(self.server), repr(self.hostmask), repr(self.protocol_version))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Serv')
        arguments.append(encode(self.cls))
        arguments.append(encode(self.s))
        arguments.append(encode(self.c))
        arguments.append(encode(self.server))
        arguments.append(encode(self.hostmask))
        arguments.append(encode(self.protocol_version))
        return Line(source, b"206", arguments)


class TraceService(Message):
    """
    ``207 <target> Service <class> <name> <type> <active-type>``
    """

    __slots__ = ['target', 'cls', 'name', 'type', 'active_type']

    def __init__(self, source: str, target: str, cls: str, name: str, type: str, active_type: str) -> None:
        self.source = source
        self.target = target
        self.cls = cls
        self.name = name
        self.type = type
        self.active_type = active_type

    def __repr__(self) -> str:
        return 'TraceService(source={}, target={}, cls={}, name={}, type={}, active_type={})'.format(repr(self.source), repr(self.target), repr(self.cls), repr(self.name), repr(self.type), repr(self.active_type))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Service')
        arguments.append(encode(self.cls))
        arguments.append(encode(self.name))
        arguments.append(encode(self.type))
        arguments.append(encode(self.active_type))
        return Line(source, b"207", arguments)


class TraceNewtype(Message):
    """
    ``208 <target> <newtype> 0 <name>``
    """

    __slots__ = ['target', 'newtype', 'name']

    def __init__(self, source: str, target: str, newtype: str, name: str) -> None:
        self.source = source
        self.target = target
        self.newtype = newtype
        self.name = name

    def __repr__(self) -> str:
        return 'TraceNewtype(source={}, target={}, newtype={}, name={})'.format(repr(self.source), repr(self.target), repr(self.newtype), repr(self.name))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.newtype))
        arguments.append(b'0')
        arguments.append(encode(self.name))
        return Line(source, b"208", arguments)


class TraceClass(Message):
    """
    ``209 <target> Class <class> <int:count>``
    """

    __slots__ = ['target', 'cls', 'count']

    def __init__(self, source: str, target: str, cls: str, count: int) -> None:
        self.source = source
        self.target = target
        self.cls = cls
        self.count = count

    def __repr__(self) -> str:
        return 'TraceClass(source={}, target={}, cls={}, count={})'.format(repr(self.source), repr(self.target), repr(self.cls), repr(self.count))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Class')
        arguments.append(encode(self.cls))
        arguments.append(encode(str(self.count)))
        return Line(source, b"209", arguments)


class StatsLinkInfo(Message):
    """
    ``211 <target> <name> <sendq> <int:sent-messages> <int:sent-kbytes> <int:recv-messages> <int:recv-kbytes> <int:uptime>``
    """

    __slots__ = ['target', 'name', 'sendq', 'sent_messages', 'sent_kbytes', 'recv_messages', 'recv_kbytes', 'uptime']

    def __init__(self, source: str, target: str, name: str, sendq: str, sent_messages: int, sent_kbytes: int, recv_messages: int, recv_kbytes: int, uptime: int) -> None:
        self.source = source
        self.target = target
        self.name = name
        self.sendq = sendq
        self.sent_messages = sent_messages
        self.sent_kbytes = sent_kbytes
        self.recv_messages = recv_messages
        self.recv_kbytes = recv_kbytes
        self.uptime = uptime

    def __repr__(self) -> str:
        return 'StatsLinkInfo(source={}, target={}, name={}, sendq={}, sent_messages={}, sent_kbytes={}, recv_messages={}, recv_kbytes={}, uptime={})'.format(repr(self.source), repr(self.target), repr(self.name), repr(self.sendq), repr(self.sent_messages), repr(self.sent_kbytes), repr(self.recv_messages), repr(self.recv_kbytes), repr(self.uptime))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.name))
        arguments.append(encode(self.sendq))
        arguments.append(encode(str(self.sent_messages)))
        arguments.append(encode(str(self.sent_kbytes)))
        arguments.append(encode(str(self.recv_messages)))
        arguments.append(encode(str(self.recv_kbytes)))
        arguments.append(encode(str(self.uptime)))
        return Line(source, b"211", arguments)


class StatsCommands(Message):
    """
    ``212 <target> <command> <int:count> <int:bytes> <int:remote-count>``
    """

    __slots__ = ['target', 'command', 'count', 'bytecount', 'remote_count']

    def __init__(self, source: str, target: str, command: str, count: int, bytecount: int, remote_count: int) -> None:
        self.source = source
        self.target = target
        self.command = command
        self.count = count
        self.bytecount = bytecount
        self.remote_count = remote_count

    def __repr__(self) -> str:
        return 'StatsCommands(source={}, target={}, command={}, count={}, bytecount={}, remote_count={})'.format(repr(self.source), repr(self.target), repr(self.command), repr(self.count), repr(self.bytecount), repr(self.remote_count))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.command))
        arguments.append(encode(str(self.count)))
        arguments.append(encode(str(self.bytecount)))
        arguments.append(encode(str(self.remote_count)))
        return Line(source, b"212", arguments)


class StatsEnd(Message):
    """
    ``219 <target> <letter> :End of STATS report``
    """

    __slots__ = ['target', 'letter']

    def __init__(self, source: str, target: str, letter: str) -> None:
        self.source = source
        self.target = target
        self.letter = letter

    def __repr__(self) -> str:
        return 'StatsEnd(source={}, target={}, letter={})'.format(repr(self.source), repr(self.target), repr(self.letter))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.letter))
        arguments.append(b'End of STATS report')
        return Line(source, b"219", arguments)


class UserModeIs(Message):
    """
    ``221 <target> <mode>``
    """

    __slots__ = ['target', 'mode']

    def __init__(self, source: str, target: str, mode: str) -> None:
        self.source = source
        self.target = target
        self.mode = mode

    def __repr__(self) -> str:
        return 'UserModeIs(source={}, target={}, mode={})'.format(repr(self.source), repr(self.target), repr(self.mode))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.mode))
        return Line(source, b"221", arguments)


class ServListReply(Message):
    """
    ``234 <target> <name> <server> <mask> <type> <int:hopcount> <info>``
    """

    __slots__ = ['target', 'name', 'server', 'mask', 'type', 'hopcount', 'info']

    def __init__(self, source: str, target: str, name: str, server: str, mask: str, type: str, hopcount: int, info: str) -> None:
        self.source = source
        self.target = target
        self.name = name
        self.server = server
        self.mask = mask
        self.type = type
        self.hopcount = hopcount
        self.info = info

    def __repr__(self) -> str:
        return 'ServListReply(source={}, target={}, name={}, server={}, mask={}, type={}, hopcount={}, info={})'.format(repr(self.source), repr(self.target), repr(self.name), repr(self.server), repr(self.mask), repr(self.type), repr(self.hopcount), repr(self.info))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.name))
        arguments.append(encode(self.server))
        arguments.append(encode(self.mask))
        arguments.append(encode(self.type))
        arguments.append(encode(str(self.hopcount)))
        arguments.append(encode(self.info))
        return Line(source, b"234", arguments)


class ServListEnd(Message):
    """
    ``235 <target> <mask> <type> :End of service listing``
    """

    __slots__ = ['target', 'mask', 'type']

    def __init__(self, source: str, target: str, mask: str, type: str) -> None:
        self.source = source
        self.target = target
        self.mask = mask
        self.type = type

    def __repr__(self) -> str:
        return 'ServListEnd(source={}, target={}, mask={}, type={})'.format(repr(self.source), repr(self.target), repr(self.mask), repr(self.type))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.mask))
        arguments.append(encode(self.type))
        arguments.append(b'End of service listing')
        return Line(source, b"235", arguments)


class StatsUptime(Message):
    """
    ``242 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'StatsUptime(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"242", arguments)


class StatsOline(Message):
    """
    ``243 <target> O <hostmask> * <name>``
    """

    __slots__ = ['target', 'hostmask', 'name']

    def __init__(self, source: str, target: str, hostmask: str, name: str) -> None:
        self.source = source
        self.target = target
        self.hostmask = hostmask
        self.name = name

    def __repr__(self) -> str:
        return 'StatsOline(source={}, target={}, hostmask={}, name={})'.format(repr(self.source), repr(self.target), repr(self.hostmask), repr(self.name))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'O')
        arguments.append(encode(self.hostmask))
        arguments.append(b'*')
        arguments.append(encode(self.name))
        return Line(source, b"243", arguments)


class LuserClient(Message):
    """
    ``251 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'LuserClient(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"251", arguments)


class LuserOp(Message):
    """
    ``252 <target> <int:count> :operator(s) online``
    """

    __slots__ = ['target', 'count']

    def __init__(self, source: str, target: str, count: int) -> None:
        self.source = source
        self.target = target
        self.count = count

    def __repr__(self) -> str:
        return 'LuserOp(source={}, target={}, count={})'.format(repr(self.source), repr(self.target), repr(self.count))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(str(self.count)))
        arguments.append(b'operator(s) online')
        return Line(source, b"252", arguments)


class LuserUnknown(Message):
    """
    ``253 <target> <int:count> :unknown connection(s)``
    """

    __slots__ = ['target', 'count']

    def __init__(self, source: str, target: str, count: int) -> None:
        self.source = source
        self.target = target
        self.count = count

    def __repr__(self) -> str:
        return 'LuserUnknown(source={}, target={}, count={})'.format(repr(self.source), repr(self.target), repr(self.count))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(str(self.count)))
        arguments.append(b'unknown connection(s)')
        return Line(source, b"253", arguments)


class LuserChannels(Message):
    """
    ``254 <target> <int:count> :channels formed``
    """

    __slots__ = ['target', 'count']

    def __init__(self, source: str, target: str, count: int) -> None:
        self.source = source
        self.target = target
        self.count = count

    def __repr__(self) -> str:
        return 'LuserChannels(source={}, target={}, count={})'.format(repr(self.source), repr(self.target), repr(self.count))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(str(self.count)))
        arguments.append(b'channels formed')
        return Line(source, b"254", arguments)


class LuserMe(Message):
    """
    ``255 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'LuserMe(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"255", arguments)


class AdminMe(Message):
    """
    ``256 <target> <server> :Administrative info``
    """

    __slots__ = ['target', 'server']

    def __init__(self, source: str, target: str, server: str) -> None:
        self.source = source
        self.target = target
        self.server = server

    def __repr__(self) -> str:
        return 'AdminMe(source={}, target={}, server={})'.format(repr(self.source), repr(self.target), repr(self.server))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.server))
        arguments.append(b'Administrative info')
        return Line(source, b"256", arguments)


class AdminLoc1(Message):
    """
    ``257 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'AdminLoc1(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"257", arguments)


class AdminLoc2(Message):
    """
    ``258 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'AdminLoc2(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"258", arguments)


class AdminEmail(Message):
    """
    ``259 <target> <email>``
    """

    __slots__ = ['target', 'email']

    def __init__(self, source: str, target: str, email: str) -> None:
        self.source = source
        self.target = target
        self.email = email

    def __repr__(self) -> str:
        return 'AdminEmail(source={}, target={}, email={})'.format(repr(self.source), repr(self.target), repr(self.email))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.email))
        return Line(source, b"259", arguments)


class TraceLog(Message):
    """
    ``261 <target> File <logfile> <debug-level>``
    """

    __slots__ = ['target', 'logfile', 'debug_level']

    def __init__(self, source: str, target: str, logfile: str, debug_level: str) -> None:
        self.source = source
        self.target = target
        self.logfile = logfile
        self.debug_level = debug_level

    def __repr__(self) -> str:
        return 'TraceLog(source={}, target={}, logfile={}, debug_level={})'.format(repr(self.source), repr(self.target), repr(self.logfile), repr(self.debug_level))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'File')
        arguments.append(encode(self.logfile))
        arguments.append(encode(self.debug_level))
        return Line(source, b"261", arguments)


class TraceEnd(Message):
    """
    ``262 <target> <server> <version> :End of TRACE``
    """

    __slots__ = ['target', 'server', 'version']

    def __init__(self, source: str, target: str, server: str, version: str) -> None:
        self.source = source
        self.target = target
        self.server = server
        self.version = version

    def __repr__(self) -> str:
        return 'TraceEnd(source={}, target={}, server={}, version={})'.format(repr(self.source), repr(self.target), repr(self.server), repr(self.version))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.server))
        arguments.append(encode(self.version))
        arguments.append(b'End of TRACE')
        return Line(source, b"262", arguments)


class TryAgain(Message):
    """
    ``263 <target> <command> :Please wait a while and try again.``
    """

    __slots__ = ['target', 'command']

    def __init__(self, source: str, target: str, command: str) -> None:
        self.source = source
        self.target = target
        self.command = command

    def __repr__(self) -> str:
        return 'TryAgain(source={}, target={}, command={})'.format(repr(self.source), repr(self.target), repr(self.command))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.command))
        arguments.append(b'Please wait a while and try again.')
        return Line(source, b"263", arguments)


class AwayReply(Message):
    """
    ``301 <target> <nickname> <message>``
    """

    __slots__ = ['target', 'nickname', 'message']

    def __init__(self, source: str, target: str, nickname: str, message: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname
        self.message = message

    def __repr__(self) -> str:
        return 'AwayReply(source={}, target={}, nickname={}, message={})'.format(repr(self.source), repr(self.target), repr(self.nickname), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.message))
        return Line(source, b"301", arguments)


class UserHostReply(Message):
    """
    ``302 <target> <message>``

    FIXME parse data!
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'UserHostReply(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"302", arguments)


class IsOnReply(Message):
    """
    ``303 <target> <message>``

    FIXME parse data!
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'IsOnReply(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"303", arguments)


class UnawayReply(Message):
    """
    ``305 <target> :You are no longer marked as being away``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'UnawayReply(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'You are no longer marked as being away')
        return Line(source, b"305", arguments)


class NowAwayReply(Message):
    """
    ``306 <target> :You have been marked as being away``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NowAwayReply(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'You have been marked as being away')
        return Line(source, b"306", arguments)


class WhoIsUser(Message):
    """
    ``311 <target> <nickname> <user> <host> * <realname>``
    """

    __slots__ = ['target', 'nickname', 'user', 'host', 'realname']

    def __init__(self, source: str, target: str, nickname: str, user: str, host: str, realname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname
        self.user = user
        self.host = host
        self.realname = realname

    def __repr__(self) -> str:
        return 'WhoIsUser(source={}, target={}, nickname={}, user={}, host={}, realname={})'.format(repr(self.source), repr(self.target), repr(self.nickname), repr(self.user), repr(self.host), repr(self.realname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.user))
        arguments.append(encode(self.host))
        arguments.append(b'*')
        arguments.append(encode(self.realname))
        return Line(source, b"311", arguments)


class WhoIsServer(Message):
    """
    ``312 <target> <nickname> <server> <info>``
    """

    __slots__ = ['target', 'nickname', 'server', 'info']

    def __init__(self, source: str, target: str, nickname: str, server: str, info: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname
        self.server = server
        self.info = info

    def __repr__(self) -> str:
        return 'WhoIsServer(source={}, target={}, nickname={}, server={}, info={})'.format(repr(self.source), repr(self.target), repr(self.nickname), repr(self.server), repr(self.info))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.server))
        arguments.append(encode(self.info))
        return Line(source, b"312", arguments)


class WhoIsOperator(Message):
    """
    ``313 <target> <nickname> :is an IRC operator``
    """

    __slots__ = ['target', 'nickname']

    def __init__(self, source: str, target: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'WhoIsOperator(source={}, target={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(b'is an IRC operator')
        return Line(source, b"313", arguments)


class WhoWasUser(Message):
    """
    ``314 <target> <nickname> <user> <host> * <realname>``
    """

    __slots__ = ['target', 'nickname', 'user', 'host', 'realname']

    def __init__(self, source: str, target: str, nickname: str, user: str, host: str, realname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname
        self.user = user
        self.host = host
        self.realname = realname

    def __repr__(self) -> str:
        return 'WhoWasUser(source={}, target={}, nickname={}, user={}, host={}, realname={})'.format(repr(self.source), repr(self.target), repr(self.nickname), repr(self.user), repr(self.host), repr(self.realname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.user))
        arguments.append(encode(self.host))
        arguments.append(b'*')
        arguments.append(encode(self.realname))
        return Line(source, b"314", arguments)


class WhoEnd(Message):
    """
    ``315 <target> <name> :End of WHO list``
    """

    __slots__ = ['target', 'name']

    def __init__(self, source: str, target: str, name: str) -> None:
        self.source = source
        self.target = target
        self.name = name

    def __repr__(self) -> str:
        return 'WhoEnd(source={}, target={}, name={})'.format(repr(self.source), repr(self.target), repr(self.name))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.name))
        arguments.append(b'End of WHO list')
        return Line(source, b"315", arguments)


class WhoIsIdle(Message):
    """
    ``317 <target> <nickname> <int:time> :seconds idle``
    """

    __slots__ = ['target', 'nickname', 'time']

    def __init__(self, source: str, target: str, nickname: str, time: int) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname
        self.time = time

    def __repr__(self) -> str:
        return 'WhoIsIdle(source={}, target={}, nickname={}, time={})'.format(repr(self.source), repr(self.target), repr(self.nickname), repr(self.time))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(encode(str(self.time)))
        arguments.append(b'seconds idle')
        return Line(source, b"317", arguments)


class WhoIsEnd(Message):
    """
    ``318 <target> <nickname> :End of WHOIS list``
    """

    __slots__ = ['target', 'nickname']

    def __init__(self, source: str, target: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'WhoIsEnd(source={}, target={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(b'End of WHOIS list')
        return Line(source, b"318", arguments)


class WhoIsChannels(Message):
    """
    ``319 <target> <nickname> <channels>``
    """

    __slots__ = ['target', 'nickname', 'channels']

    def __init__(self, source: str, target: str, nickname: str, channels: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname
        self.channels = channels

    def __repr__(self) -> str:
        return 'WhoIsChannels(source={}, target={}, nickname={}, channels={})'.format(repr(self.source), repr(self.target), repr(self.nickname), repr(self.channels))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.channels))
        return Line(source, b"319", arguments)


class ListReply(Message):
    """
    ``322 <target> <channel> <int:visible> <topic>``
    """

    __slots__ = ['target', 'channel', 'visible', 'topic']

    def __init__(self, source: str, target: str, channel: str, visible: int, topic: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.visible = visible
        self.topic = topic

    def __repr__(self) -> str:
        return 'ListReply(source={}, target={}, channel={}, visible={}, topic={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.visible), repr(self.topic))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(str(self.visible)))
        arguments.append(encode(self.topic))
        return Line(source, b"322", arguments)


class ListEnd(Message):
    """
    ``323 <target> :End of LIST``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'ListEnd(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'End of LIST')
        return Line(source, b"323", arguments)


class ChannelModeIs(Message):
    """
    ``324 <target> <channel> <mode> <params>``
    """

    __slots__ = ['target', 'channel', 'mode', 'params']

    def __init__(self, source: str, target: str, channel: str, mode: str, params: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.mode = mode
        self.params = params

    def __repr__(self) -> str:
        return 'ChannelModeIs(source={}, target={}, channel={}, mode={}, params={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.mode), repr(self.params))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.mode))
        arguments.append(encode(self.params))
        return Line(source, b"324", arguments)


class UniqOpIs(Message):
    """
    ``325 <target> <channel> <nickname>``
    """

    __slots__ = ['target', 'channel', 'nickname']

    def __init__(self, source: str, target: str, channel: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'UniqOpIs(source={}, target={}, channel={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.nickname))
        return Line(source, b"325", arguments)


class NoTopicReply(Message):
    """
    ``331 <target> <channel> :No topic is set``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'NoTopicReply(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'No topic is set')
        return Line(source, b"331", arguments)


class TopicReply(Message):
    """
    ``332 <target> <channel> <topic>``
    """

    __slots__ = ['target', 'channel', 'topic']

    def __init__(self, source: str, target: str, channel: str, topic: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.topic = topic

    def __repr__(self) -> str:
        return 'TopicReply(source={}, target={}, channel={}, topic={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.topic))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.topic))
        return Line(source, b"332", arguments)


class Inviting(Message):
    """
    ``341 <target> <channel> <nick>``
    """

    __slots__ = ['target', 'channel', 'nick']

    def __init__(self, source: str, target: str, channel: str, nick: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.nick = nick

    def __repr__(self) -> str:
        return 'Inviting(source={}, target={}, channel={}, nick={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.nick))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.nick))
        return Line(source, b"341", arguments)


class Summoning(Message):
    """
    ``342 <target> <user> :Summoning user to IRC``
    """

    __slots__ = ['target', 'user']

    def __init__(self, source: str, target: str, user: str) -> None:
        self.source = source
        self.target = target
        self.user = user

    def __repr__(self) -> str:
        return 'Summoning(source={}, target={}, user={})'.format(repr(self.source), repr(self.target), repr(self.user))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.user))
        arguments.append(b'Summoning user to IRC')
        return Line(source, b"342", arguments)


class InviteList(Message):
    """
    ``346 <target> <channel> <mask>``
    """

    __slots__ = ['target', 'channel', 'mask']

    def __init__(self, source: str, target: str, channel: str, mask: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.mask = mask

    def __repr__(self) -> str:
        return 'InviteList(source={}, target={}, channel={}, mask={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.mask))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.mask))
        return Line(source, b"346", arguments)


class InviteListEnd(Message):
    """
    ``347 <target> <channel> :End of channel invite list``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'InviteListEnd(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'End of channel invite list')
        return Line(source, b"347", arguments)


class ExceptList(Message):
    """
    ``348 <target> <channel> <mask>``
    """

    __slots__ = ['target', 'channel', 'mask']

    def __init__(self, source: str, target: str, channel: str, mask: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.mask = mask

    def __repr__(self) -> str:
        return 'ExceptList(source={}, target={}, channel={}, mask={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.mask))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.mask))
        return Line(source, b"348", arguments)


class ExceptListEnd(Message):
    """
    ``349 <target> <channel> :End of channel exception list``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'ExceptListEnd(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'End of channel exception list')
        return Line(source, b"349", arguments)


class VersionReply(Message):
    """
    ``351 <target> <version> <server> <comments>``
    """

    __slots__ = ['target', 'version', 'server', 'comments']

    def __init__(self, source: str, target: str, version: str, server: str, comments: str) -> None:
        self.source = source
        self.target = target
        self.version = version
        self.server = server
        self.comments = comments

    def __repr__(self) -> str:
        return 'VersionReply(source={}, target={}, version={}, server={}, comments={})'.format(repr(self.source), repr(self.target), repr(self.version), repr(self.server), repr(self.comments))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.version))
        arguments.append(encode(self.server))
        arguments.append(encode(self.comments))
        return Line(source, b"351", arguments)


class WhoReply(Message):
    """
    ``352 <target> <channel> <user> <host> <server> <nickname> <props> <realname>``
    """

    __slots__ = ['target', 'channel', 'user', 'host', 'server', 'nickname', 'props', 'realname']

    def __init__(self, source: str, target: str, channel: str, user: str, host: str, server: str, nickname: str, props: str, realname: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.user = user
        self.host = host
        self.server = server
        self.nickname = nickname
        self.props = props
        self.realname = realname

    def __repr__(self) -> str:
        return 'WhoReply(source={}, target={}, channel={}, user={}, host={}, server={}, nickname={}, props={}, realname={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.user), repr(self.host), repr(self.server), repr(self.nickname), repr(self.props), repr(self.realname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.user))
        arguments.append(encode(self.host))
        arguments.append(encode(self.server))
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.props))
        arguments.append(encode(self.realname))
        return Line(source, b"352", arguments)


class NamesReply(Message):
    """
    ``353 <target> <mode> <channel> <nicknames_>``
    """

    __slots__ = ['target', 'mode', 'channel', 'nicknames']

    def __init__(self, source: str, target: str, mode: str, channel: str, nicknames: typing.List[str]) -> None:
        self.source = source
        self.target = target
        self.mode = mode
        self.channel = channel
        self.nicknames = nicknames

    def __repr__(self) -> str:
        return 'NamesReply(source={}, target={}, mode={}, channel={}, nicknames={})'.format(repr(self.source), repr(self.target), repr(self.mode), repr(self.channel), repr(self.nicknames))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.mode))
        arguments.append(encode(self.channel))
        arguments.append(b" ".join(encode(x) for x in self.nicknames))
        return Line(source, b"353", arguments)


class LinksReply(Message):
    """
    ``364 <target> <mask> <server> <info>``
    """

    __slots__ = ['target', 'mask', 'server', 'info']

    def __init__(self, source: str, target: str, mask: str, server: str, info: str) -> None:
        self.source = source
        self.target = target
        self.mask = mask
        self.server = server
        self.info = info

    def __repr__(self) -> str:
        return 'LinksReply(source={}, target={}, mask={}, server={}, info={})'.format(repr(self.source), repr(self.target), repr(self.mask), repr(self.server), repr(self.info))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.mask))
        arguments.append(encode(self.server))
        arguments.append(encode(self.info))
        return Line(source, b"364", arguments)


class LinksEnd(Message):
    """
    ``365 <target> <mask> :End of LINKS list``
    """

    __slots__ = ['target', 'mask']

    def __init__(self, source: str, target: str, mask: str) -> None:
        self.source = source
        self.target = target
        self.mask = mask

    def __repr__(self) -> str:
        return 'LinksEnd(source={}, target={}, mask={})'.format(repr(self.source), repr(self.target), repr(self.mask))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.mask))
        arguments.append(b'End of LINKS list')
        return Line(source, b"365", arguments)


class NamesEnd(Message):
    """
    ``366 <target> <channel> :End of NAMES list``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'NamesEnd(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'End of NAMES list')
        return Line(source, b"366", arguments)


class BanList(Message):
    """
    ``367 <target> <channel> <mask>``
    """

    __slots__ = ['target', 'channel', 'mask']

    def __init__(self, source: str, target: str, channel: str, mask: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.mask = mask

    def __repr__(self) -> str:
        return 'BanList(source={}, target={}, channel={}, mask={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.mask))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.mask))
        return Line(source, b"367", arguments)


class BanListEnd(Message):
    """
    ``368 <target> <channel> :End of channel ban list``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'BanListEnd(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'End of channel ban list')
        return Line(source, b"368", arguments)


class WhoWasEnd(Message):
    """
    ``369 <target> <nickname> :End of WHOWAS``
    """

    __slots__ = ['target', 'nickname']

    def __init__(self, source: str, target: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'WhoWasEnd(source={}, target={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(b'End of WHOWAS')
        return Line(source, b"369", arguments)


class InfoReply(Message):
    """
    ``371 <target> <info>``
    """

    __slots__ = ['target', 'info']

    def __init__(self, source: str, target: str, info: str) -> None:
        self.source = source
        self.target = target
        self.info = info

    def __repr__(self) -> str:
        return 'InfoReply(source={}, target={}, info={})'.format(repr(self.source), repr(self.target), repr(self.info))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.info))
        return Line(source, b"371", arguments)


class MotdText(Message):
    """
    ``372 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'MotdText(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"372", arguments)


class InfoEnd(Message):
    """
    ``374 <target> :End of INFO list``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'InfoEnd(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'End of INFO list')
        return Line(source, b"374", arguments)


class MotdStart(Message):
    """
    ``375 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'MotdStart(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"375", arguments)


class MotdEnd(Message):
    """
    ``376 <target> :End of MOTD command``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'MotdEnd(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'End of MOTD command')
        return Line(source, b"376", arguments)


class YoureOper(Message):
    """
    ``381 <target> :You are now an IRC operator``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'YoureOper(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'You are now an IRC operator')
        return Line(source, b"381", arguments)


class Rehashing(Message):
    """
    ``382 <target> <file> Rehashing``
    """

    __slots__ = ['target', 'file']

    def __init__(self, source: str, target: str, file: str) -> None:
        self.source = source
        self.target = target
        self.file = file

    def __repr__(self) -> str:
        return 'Rehashing(source={}, target={}, file={})'.format(repr(self.source), repr(self.target), repr(self.file))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.file))
        arguments.append(b'Rehashing')
        return Line(source, b"382", arguments)


class YoureService(Message):
    """
    ``383 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'YoureService(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"383", arguments)


class TimeReply(Message):
    """
    ``391 <target> <server> <time>``
    """

    __slots__ = ['target', 'server', 'time']

    def __init__(self, source: str, target: str, server: str, time: str) -> None:
        self.source = source
        self.target = target
        self.server = server
        self.time = time

    def __repr__(self) -> str:
        return 'TimeReply(source={}, target={}, server={}, time={})'.format(repr(self.source), repr(self.target), repr(self.server), repr(self.time))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.server))
        arguments.append(encode(self.time))
        return Line(source, b"391", arguments)


class UsersStart(Message):
    """
    ``392 <target> :UserID   Terminal  Host``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'UsersStart(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'UserID   Terminal  Host')
        return Line(source, b"392", arguments)


class UsersReply(Message):
    """
    ``393 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'UsersReply(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"393", arguments)


class UsersEnd(Message):
    """
    ``394 <target> :End of users``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'UsersEnd(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'End of users')
        return Line(source, b"394", arguments)


class NoUsers(Message):
    """
    ``395 <target> :Nobody logged in``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoUsers(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Nobody logged in')
        return Line(source, b"395", arguments)


class NoSuchNick(Message):
    """
    ``401 <target> <nickname> :No such nick/channel``
    """

    __slots__ = ['target', 'nickname']

    def __init__(self, source: str, target: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'NoSuchNick(source={}, target={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(b'No such nick/channel')
        return Line(source, b"401", arguments)


class NoSuchServer(Message):
    """
    ``402 <target> <server> :No such server``
    """

    __slots__ = ['target', 'server']

    def __init__(self, source: str, target: str, server: str) -> None:
        self.source = source
        self.target = target
        self.server = server

    def __repr__(self) -> str:
        return 'NoSuchServer(source={}, target={}, server={})'.format(repr(self.source), repr(self.target), repr(self.server))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.server))
        arguments.append(b'No such server')
        return Line(source, b"402", arguments)


class NoSuchChannel(Message):
    """
    ``403 <target> <channel> :No such channel``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'NoSuchChannel(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'No such channel')
        return Line(source, b"403", arguments)


class CantSendToChan(Message):
    """
    ``404 <target> <channel> :Cannot send to channel``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'CantSendToChan(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'Cannot send to channel')
        return Line(source, b"404", arguments)


class TooManyChannels(Message):
    """
    ``405 <target> <channel> :You have joined too many channels``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'TooManyChannels(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'You have joined too many channels')
        return Line(source, b"405", arguments)


class WasNoSuchNick(Message):
    """
    ``406 <target> <nickname> :There was no such nickname``
    """

    __slots__ = ['target', 'nickname']

    def __init__(self, source: str, target: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'WasNoSuchNick(source={}, target={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(b'There was no such nickname')
        return Line(source, b"406", arguments)


class TooManyTargets(Message):
    """
    ``407 <target> <orig-target> <message>``
    """

    __slots__ = ['target', 'orig_target', 'message']

    def __init__(self, source: str, target: str, orig_target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.orig_target = orig_target
        self.message = message

    def __repr__(self) -> str:
        return 'TooManyTargets(source={}, target={}, orig_target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.orig_target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.orig_target))
        arguments.append(encode(self.message))
        return Line(source, b"407", arguments)


class NoSuchService(Message):
    """
    ``408 <target> <name> :No such service``
    """

    __slots__ = ['target', 'name']

    def __init__(self, source: str, target: str, name: str) -> None:
        self.source = source
        self.target = target
        self.name = name

    def __repr__(self) -> str:
        return 'NoSuchService(source={}, target={}, name={})'.format(repr(self.source), repr(self.target), repr(self.name))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.name))
        arguments.append(b'No such service')
        return Line(source, b"408", arguments)


class NoOrigin(Message):
    """
    ``409 <target> :No origin specified``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoOrigin(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'No origin specified')
        return Line(source, b"409", arguments)


class NoRecipient(Message):
    """
    ``411 <target> :No recipient given``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoRecipient(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'No recipient given')
        return Line(source, b"411", arguments)


class NoTextToSend(Message):
    """
    ``412 <target> :No text to send``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoTextToSend(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'No text to send')
        return Line(source, b"412", arguments)


class NoTopLevel(Message):
    """
    ``413 <target> <mask> :No toplevel domain specified``
    """

    __slots__ = ['target', 'mask']

    def __init__(self, source: str, target: str, mask: str) -> None:
        self.source = source
        self.target = target
        self.mask = mask

    def __repr__(self) -> str:
        return 'NoTopLevel(source={}, target={}, mask={})'.format(repr(self.source), repr(self.target), repr(self.mask))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.mask))
        arguments.append(b'No toplevel domain specified')
        return Line(source, b"413", arguments)


class WildTopLevel(Message):
    """
    ``414 <target> <mask> :Wildcard in toplevel domain``
    """

    __slots__ = ['target', 'mask']

    def __init__(self, source: str, target: str, mask: str) -> None:
        self.source = source
        self.target = target
        self.mask = mask

    def __repr__(self) -> str:
        return 'WildTopLevel(source={}, target={}, mask={})'.format(repr(self.source), repr(self.target), repr(self.mask))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.mask))
        arguments.append(b'Wildcard in toplevel domain')
        return Line(source, b"414", arguments)


class BadMask(Message):
    """
    ``415 <target> <mask> :Bad Server/host mask``
    """

    __slots__ = ['target', 'mask']

    def __init__(self, source: str, target: str, mask: str) -> None:
        self.source = source
        self.target = target
        self.mask = mask

    def __repr__(self) -> str:
        return 'BadMask(source={}, target={}, mask={})'.format(repr(self.source), repr(self.target), repr(self.mask))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.mask))
        arguments.append(b'Bad Server/host mask')
        return Line(source, b"415", arguments)


class UnknownCommand(Message):
    """
    ``421 <target> <command> :Unknown command``
    """

    __slots__ = ['target', 'command']

    def __init__(self, source: str, target: str, command: str) -> None:
        self.source = source
        self.target = target
        self.command = command

    def __repr__(self) -> str:
        return 'UnknownCommand(source={}, target={}, command={})'.format(repr(self.source), repr(self.target), repr(self.command))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.command))
        arguments.append(b'Unknown command')
        return Line(source, b"421", arguments)


class NoMotd(Message):
    """
    ``422 <target> :MOTD File is missing``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoMotd(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'MOTD File is missing')
        return Line(source, b"422", arguments)


class NoAdminInfo(Message):
    """
    ``423 <target> <server> :No administrative info available``
    """

    __slots__ = ['target', 'server']

    def __init__(self, source: str, target: str, server: str) -> None:
        self.source = source
        self.target = target
        self.server = server

    def __repr__(self) -> str:
        return 'NoAdminInfo(source={}, target={}, server={})'.format(repr(self.source), repr(self.target), repr(self.server))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.server))
        arguments.append(b'No administrative info available')
        return Line(source, b"423", arguments)


class FileError(Message):
    """
    ``424 <target> <message>``
    """

    __slots__ = ['target', 'message']

    def __init__(self, source: str, target: str, message: str) -> None:
        self.source = source
        self.target = target
        self.message = message

    def __repr__(self) -> str:
        return 'FileError(source={}, target={}, message={})'.format(repr(self.source), repr(self.target), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.message))
        return Line(source, b"424", arguments)


class NoNicknameGiven(Message):
    """
    ``431 <target> :No nickname given``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoNicknameGiven(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'No nickname given')
        return Line(source, b"431", arguments)


class ErroneusNickname(Message):
    """
    ``432 <target> <nickname> :Erroneous nickname``
    """

    __slots__ = ['target', 'nickname']

    def __init__(self, source: str, target: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'ErroneusNickname(source={}, target={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(b'Erroneous nickname')
        return Line(source, b"432", arguments)


class NicknameInUse(Message):
    """
    ``433 <target> <nickname> :Nickname is already in use``
    """

    __slots__ = ['target', 'nickname']

    def __init__(self, source: str, target: str, nickname: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname

    def __repr__(self) -> str:
        return 'NicknameInUse(source={}, target={}, nickname={})'.format(repr(self.source), repr(self.target), repr(self.nickname))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(b'Nickname is already in use')
        return Line(source, b"433", arguments)


class NickCollision(Message):
    """
    ``436 <target> <nickname> <message>``
    """

    __slots__ = ['target', 'nickname', 'message']

    def __init__(self, source: str, target: str, nickname: str, message: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname
        self.message = message

    def __repr__(self) -> str:
        return 'NickCollision(source={}, target={}, nickname={}, message={})'.format(repr(self.source), repr(self.target), repr(self.nickname), repr(self.message))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.message))
        return Line(source, b"436", arguments)


class UnavailResource(Message):
    """
    ``437 <target> <name> :Nick/channel is temporarily unavailable``
    """

    __slots__ = ['target', 'name']

    def __init__(self, source: str, target: str, name: str) -> None:
        self.source = source
        self.target = target
        self.name = name

    def __repr__(self) -> str:
        return 'UnavailResource(source={}, target={}, name={})'.format(repr(self.source), repr(self.target), repr(self.name))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.name))
        arguments.append(b'Nick/channel is temporarily unavailable')
        return Line(source, b"437", arguments)


class UserNotInChannel(Message):
    """
    ``441 <target> <nickname> <channel> :They aren't on that channel``
    """

    __slots__ = ['target', 'nickname', 'channel']

    def __init__(self, source: str, target: str, nickname: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.nickname = nickname
        self.channel = channel

    def __repr__(self) -> str:
        return 'UserNotInChannel(source={}, target={}, nickname={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.nickname), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.nickname))
        arguments.append(encode(self.channel))
        arguments.append(b"They aren't on that channel")
        return Line(source, b"441", arguments)


class NotOnChannel(Message):
    """
    ``442 <target> <channel> :You're not on that channel``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'NotOnChannel(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b"You're not on that channel")
        return Line(source, b"442", arguments)


class UserOnChannel(Message):
    """
    ``443 <target> <user> <channel> :is already on channel``
    """

    __slots__ = ['target', 'user', 'channel']

    def __init__(self, source: str, target: str, user: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.user = user
        self.channel = channel

    def __repr__(self) -> str:
        return 'UserOnChannel(source={}, target={}, user={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.user), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.user))
        arguments.append(encode(self.channel))
        arguments.append(b'is already on channel')
        return Line(source, b"443", arguments)


class NoLogin(Message):
    """
    ``444 <target> <user> :User not logged in``
    """

    __slots__ = ['target', 'user']

    def __init__(self, source: str, target: str, user: str) -> None:
        self.source = source
        self.target = target
        self.user = user

    def __repr__(self) -> str:
        return 'NoLogin(source={}, target={}, user={})'.format(repr(self.source), repr(self.target), repr(self.user))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.user))
        arguments.append(b'User not logged in')
        return Line(source, b"444", arguments)


class SummonDisabled(Message):
    """
    ``445 <target> :SUMMON has been disabled``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'SummonDisabled(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'SUMMON has been disabled')
        return Line(source, b"445", arguments)


class UsersDisabled(Message):
    """
    ``446 <target> :USERS has been disabled``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'UsersDisabled(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'USERS has been disabled')
        return Line(source, b"446", arguments)


class NotRegistered(Message):
    """
    ``451 <target> :You have not registered``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NotRegistered(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'You have not registered')
        return Line(source, b"451", arguments)


class NeedMoreParams(Message):
    """
    ``461 <target> <command> :Not enough parameters``
    """

    __slots__ = ['target', 'command']

    def __init__(self, source: str, target: str, command: str) -> None:
        self.source = source
        self.target = target
        self.command = command

    def __repr__(self) -> str:
        return 'NeedMoreParams(source={}, target={}, command={})'.format(repr(self.source), repr(self.target), repr(self.command))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.command))
        arguments.append(b'Not enough parameters')
        return Line(source, b"461", arguments)


class AlreadyRegistered(Message):
    """
    ``462 <target> :Unauthorized command (already registered)``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'AlreadyRegistered(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Unauthorized command (already registered)')
        return Line(source, b"462", arguments)


class NoPermForHost(Message):
    """
    ``463 <target> :Your host isn't among the privileged``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoPermForHost(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b"Your host isn't among the privileged")
        return Line(source, b"463", arguments)


class PasswordMismatch(Message):
    """
    ``464 <target> :Password incorrect``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'PasswordMismatch(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Password incorrect')
        return Line(source, b"464", arguments)


class YoureBannedCreep(Message):
    """
    ``465 <target> :You are banned from this server``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'YoureBannedCreep(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'You are banned from this server')
        return Line(source, b"465", arguments)


class YouWillBeBanned(Message):
    """
    ``466 <target>``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'YouWillBeBanned(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        return Line(source, b"466", arguments)


class KeySet(Message):
    """
    ``467 <target> <channel> :Channel key already set``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'KeySet(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'Channel key already set')
        return Line(source, b"467", arguments)


class ChannelIsFull(Message):
    """
    ``471 <target> <channel> :Cannot join channel (+l)``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'ChannelIsFull(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'Cannot join channel (+l)')
        return Line(source, b"471", arguments)


class UnknownMode(Message):
    """
    ``472 <target> <char> :is unknown mode char to me``
    """

    __slots__ = ['target', 'char']

    def __init__(self, source: str, target: str, char: str) -> None:
        self.source = source
        self.target = target
        self.char = char

    def __repr__(self) -> str:
        return 'UnknownMode(source={}, target={}, char={})'.format(repr(self.source), repr(self.target), repr(self.char))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.char))
        arguments.append(b'is unknown mode char to me')
        return Line(source, b"472", arguments)


class InviteOnlyChan(Message):
    """
    ``473 <target> <channel> :Cannot join channel (+i)``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'InviteOnlyChan(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'Cannot join channel (+i)')
        return Line(source, b"473", arguments)


class BannedFromChan(Message):
    """
    ``474 <target> <channel> :Cannot join channel (+b)``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'BannedFromChan(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'Cannot join channel (+b)')
        return Line(source, b"474", arguments)


class BadChannelKey(Message):
    """
    ``475 <target> <channel> :Cannot join channel (+k)``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'BadChannelKey(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'Cannot join channel (+k)')
        return Line(source, b"475", arguments)


class BadChanMask(Message):
    """
    ``476 <target> <channel> :Bad Channel Mask``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'BadChanMask(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b'Bad Channel Mask')
        return Line(source, b"476", arguments)


class NoChanModes(Message):
    """
    ``477 <target> <channel> :Channel doesn't support modes``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'NoChanModes(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b"Channel doesn't support modes")
        return Line(source, b"477", arguments)


class BanListFull(Message):
    """
    ``478 <target> <channel> <char> :Channel list is full``
    """

    __slots__ = ['target', 'channel', 'char']

    def __init__(self, source: str, target: str, channel: str, char: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel
        self.char = char

    def __repr__(self) -> str:
        return 'BanListFull(source={}, target={}, channel={}, char={})'.format(repr(self.source), repr(self.target), repr(self.channel), repr(self.char))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(encode(self.char))
        arguments.append(b'Channel list is full')
        return Line(source, b"478", arguments)


class NoPrivileges(Message):
    """
    ``481 <target> :Permission Denied- You're not an IRC operator``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoPrivileges(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b"Permission Denied- You're not an IRC operator")
        return Line(source, b"481", arguments)


class ChanOpPrivsNeeded(Message):
    """
    ``482 <target> <channel> :You're not channel operator``
    """

    __slots__ = ['target', 'channel']

    def __init__(self, source: str, target: str, channel: str) -> None:
        self.source = source
        self.target = target
        self.channel = channel

    def __repr__(self) -> str:
        return 'ChanOpPrivsNeeded(source={}, target={}, channel={})'.format(repr(self.source), repr(self.target), repr(self.channel))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(encode(self.channel))
        arguments.append(b"You're not channel operator")
        return Line(source, b"482", arguments)


class CantKillServer(Message):
    """
    ``483 <target> :You can't kill a server!``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'CantKillServer(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b"You can't kill a server!")
        return Line(source, b"483", arguments)


class Restricted(Message):
    """
    ``484 <target> :Your connection is restricted!``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'Restricted(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Your connection is restricted!')
        return Line(source, b"484", arguments)


class UniqOpPrivsNeeded(Message):
    """
    ``485 <target> :You're not the original channel operator``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'UniqOpPrivsNeeded(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b"You're not the original channel operator")
        return Line(source, b"485", arguments)


class NoOperHost(Message):
    """
    ``491 <target> :No O-lines for your host``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'NoOperHost(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'No O-lines for your host')
        return Line(source, b"491", arguments)


class UserModeUnknownFlag(Message):
    """
    ``501 <target> :Unknown MODE flag``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'UserModeUnknownFlag(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Unknown MODE flag')
        return Line(source, b"501", arguments)


class UsersDontMatch(Message):
    """
    ``502 <target> :Cannot change mode for other users``
    """

    __slots__ = ['target']

    def __init__(self, source: str, target: str) -> None:
        self.source = source
        self.target = target

    def __repr__(self) -> str:
        return 'UsersDontMatch(source={}, target={})'.format(repr(self.source), repr(self.target))

    def to_line(self, encode: typing.Callable[[str], bytes] = lambda s: s.encode("utf-8")) -> Line:
        source = None
        if self.source is not None:
            source = encode(self.source)
        arguments = []
        arguments.append(encode(self.target))
        arguments.append(b'Cannot change mode for other users')
        return Line(source, b"502", arguments)