(1 . 6)(1 . 6)
import time

VERSION = 9979
VERSION = 9978
STATUS_ONLINE = 0
STATUS_AWAY = 1

(36 . 6)(36 . 7)
        self.short_buffer = ShortBuffer(self.state)
        self.long_buffer = LongBuffer(self.state)
        self.order_buffer = OrderBuffer(self.state)
        self.getdata_requests = {}
        self.server = Server(cmd_line_options, self)
        self.handlers = {
            DIRECT: self.handle_direct,
(44 . 6)(45 . 7)
            IGNORE: self.handle_ignore
        }
        self.presence = {}
        self.last_delivered = 0

    def start(self):
        self.server.start()
(106 . 7)(108 . 6)
    def handle_direct(self, message):
        message.log_incoming(message.peer)
        self.deliver(message)
        self.long_buffer.intern(message)
        self.conditionally_update_at(message, message.metadata["address"])

    def handle_broadcast(self, message):
(119 . 7)(120 . 6)
            if self.short_buffer.has(message.message_hash):
                self.short_buffer.drop(message.message_hash)
            self.deliver(message)
            self.long_buffer.intern(message)
            self.state.update_net_chain(message.message_hash)
            self.rebroadcast(message)
        else:
(166 . 7)(166 . 6)
                message.prefix = "%s[%d]" % (message.speaker, len(message_with_stats['closest_peers']))

            self.deliver(message)
            self.long_buffer.intern(message)
            self.state.update_net_chain(message.message_hash)
            message.reporting_peers = message_with_stats['reporting_peers']
            self.rebroadcast(message)
(226 . 10)(225 . 18)
        port = packet_info[1]
        logging.debug(
            "[%s:%d] -> message received out of order: %s" % (address, port, binascii.hexlify(message['message_hash'])))
        if not self.order_buffer.has(message['message_hash']):
            for chain in broken_chains:
        for chain in broken_chains:
            if not self.getdata_requests.get(message[chain]):
                GetData(message, chain, self.state).send()
                self.getdata_requests[message[chain]] = time.time()
        self.order_buffer.add(message)
        self.clean_getdata_requests()

    def clean_getdata_requests(self):
        for message_hash in self.getdata_requests.keys():
            if (self.getdata_requests.get(message_hash) <
                    time.time() - self.state.get_knob('getdata_requests_expiration_seconds')):
                del self.getdata_requests[message_hash]

    def deliver(self, message):
        # it's possible that these messages are from an order buffer
(238 . 18)(245 . 24)
        if self.long_buffer.has(message.message_hash):
            return


        # send to the irc client
        if self.client:
            # emit a replay warning if this message is a getdata response and older than the last
            # displayed message
            if message.get_data_response:
                if message.timestamp < self.state.get_latest_message_timestamp():
                if message.timestamp < self.last_delivered:
                    warning = time.strftime(
                        "Replay: %Y-%m-%d %H:%M:%S:",
                        time.localtime(message.timestamp)
                    )
                    self.client.pest_reply(warning)
                    if message.command == BROADCAST:
                        self.client.pest_reply(warning)
                    else:
                        self.client.pest_dm_reply(message.speaker, warning)
            self.client.message_from_station(message)
            self.last_delivered = message.timestamp
        self.long_buffer.intern(message)

    # we only update the address table if the speaker is same as peer
    def conditionally_update_at(self, message, address):