```python
#!/usr/bin/env python

import socket
import threading
import signal
import sys

class Client(threading.Thread):
    mutex = threading.RLock()
    flags = {}

    def __init__(self, sock, *args, **kwargs):
        super(Client, self).__init__(*args, **kwargs)
        self.setDaemon(True)
        self.sock = sock

    @classmethod
    def add_flag(cls, flag_id, flag):
        cls.lock()
        cls.flags[flag_id] = flag
        cls.unlock()

    @classmethod
    def get_flag(cls, flag_id):
        try:
            return cls.flags[flag_id]
        except KeyError:
            ""

    @classmethod
    def lock(cls):
        cls.mutex.acquire()

    @classmethod
    def unlock(cls):
        cls.mutex.release()

    def get_line(self):
        try:
            msg = self.sock.recv(1000)
            while "\n" not in msg:
                msg += self.sock.recv(1000)
            msg = msg[:msg.find("\n")]
            return msg
        except Exception, ex:
            return ""

    def store_flag(self):
        global current_id
        try:
            self.sock.send("Your flag: ")
            flag = self.get_line()
            self.add_flag(current_id, flag)
            self.sock.send("Flag successfully stored at id %d!\n" % current_id)
            print "Got flag %s" % flag
            current_id += 1
        except Exception, ex:
            print ex
            self.sock.close()

    def print_flag(self):
        try:
            self.sock.send("Enter flag id: ")
            flag_id = int(self.get_line())
            flag = self.get_flag(flag_id)
            if flag:
                self.sock.send("Here is your flag: %s!\n" % flag)
            else:
                self.sock.send("No such flag!\n")
        except ValueError:
            self.sock.send("Id must be integer!\n")
            self.print_flag()
        except Exception, ex:
            print ex
            self.sock.close()

    def run(self):
        self.sock.send("Hi there! Enter your command:\n")
        self.sock.send("1. Store flag\n")
        self.sock.send("2. Get flag\n")
        self.sock.send("3. Exit\n")

        while sock:
            try:
                self.sock.send("> ")
                msg = self.sock.recv(100500)
                cmd = msg.strip()
            except:
                break
            if cmd == "1":
                self.store_flag()
            if cmd == "2":
                self.print_flag()
            if cmd == "3":
                self.sock.send("Goodbye!\n")
                self.sock.close()
        self.sock.close()

asock = None
current_id = 0
def shutdown_handler(signal_num, stack_frame):
    global asock
    asock.shutdown(socket.SHUT_RDWR)
    asock.close()
    asock = None
    sys.exit(0)

if __name__ == "__main__":
    signal.signal(signal.SIGINT, shutdown_handler)
    current_id = 0
    asock = socket.socket()
    asock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    asock.bind(("0.0.0.0", 1337))
    asock.listen(100)
    try:
        while True:
            sock = asock.accept()[0]
            Client(sock).start()
    except Exception, ex:
        print ex
    asock.shutdown(socket.SHUT_RDWR)
    asock.close()
```