# Copyright (c) 2025 Martin Kayser (tebarius)
# Licensed under the MIT License. See LICENSE file in the project root.
from itertools import chain # für primfaktoren zerlegung
import helper
import hilfetexte
import pandas as pd
from urllib.parse import unquote as urllib_parse_unquote  # für nak-nak
import binascii  # für base64_ascii
import brainfuckery

def cesar_all(eingabetext):
    eingabetext = eingabetext.rstrip()

    if eingabetext == "":
        return hilfetexte.cesar_all
    else:
        abcgross = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        abcklein = "abcdefghijklmnopqrstuvwxyz"
        txt = eingabetext
        ausgabe = ""
        for r in range(1, 27):
            atxt = ""
            for i in txt:
                if i.upper() not in abcgross:
                    atxt = atxt + i  # nicht codierbare Zeichen direkt zur Ausgabe bitte!
                    continue
                abc = abcgross
                if i == i.lower():
                    abc = abcklein
                for j in range(26):
                    if i == abc[j]:
                        if j + r >= 26:
                            atxt = atxt + abc[j + r - 26]
                        else:
                            atxt = atxt + abc[j + r]
            ausgabe += f":blue[{r:02}:] {atxt}  \n"
        return ausgabe

def buchstabenwortwert(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.buchstabenwortwert
    else:
        ausgabe = ""
        bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12,
              'M': 13, 'N': 14,
              'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25,
              'Z': 26,
              'Ä': 27, 'Ö': 28, 'Ü': 29, 'SS': 30}
        wortsumme = 0
        wortprodukt = 1
        atxt = ""
        az = ""
        eworttxt = ""
        ewortptxt = ""
        banzahla = 0
        banzwtxt = ""
        einzelworte = eingabetext.split()
        for wort in einzelworte:
            ewortsumme = 0
            ewortprod = 1
            banzahlw = 0
            ewtr = False
            for b in wort:
                if b.upper() not in bw:
                    atxt = atxt + b + "=0 "
                    az = az + "0,"
                    continue
                else:
                    ewtr = True
                    ewortprod *= bw[b.upper()]
                    ewortsumme += bw[b.upper()]
                    wortsumme += bw[b.upper()]
                    wortprodukt *= bw[b.upper()]
                    atxt = atxt + b + "=" + str(bw[b.upper()]) + " "
                    az = az + str(bw[b.upper()]) + ","
                    banzahla += 1
                    banzahlw += 1
            banzwtxt = banzwtxt + str(banzahlw) + "/"
            eworttxt = eworttxt + str(ewortsumme) + "/"
            if not ewtr:
                ewortptxt = ewortptxt + "0/"
            else:
                ewortptxt = ewortptxt + str(ewortprod) + "/"

        ausgabe += atxt + "  \n"
        ausgabe += '|    |    |\n'
        ausgabe += '|----|----|\n'
        ausgabe += "|:blue[Buchstabenwerte:]|"
        ausgabe += az[0:-1] + "|\n"
        ausgabe += "|:blue[Buchstabenwortwerte:]|"
        ausgabe += eworttxt[0:-1] + "|\n"
        ausgabe += "|:blue[Summe aller Buchstabenwerte:]|"
        ausgabe += str(wortsumme) + "|\n"
        ausgabe += "|:blue[Quersumme der Summe aller Buchstabenwerte / iterierte Quersumme:]|"
        ausgabe += str(helper.q_sum(wortsumme)) + " / " + str(helper.iq_sum(wortsumme)) + "|\n"
        ausgabe += "|:blue[Buchstabenanzahl pro Wort:]|"
        ausgabe += banzwtxt[0:-1] + "|\n"
        ausgabe += "|:blue[Gesamtanzahl aller Buchstaben:]|"
        ausgabe += str(banzahla) + "|\n"
        ausgabe += "|:blue[Wortprodukte(0 wenn kein Buchstabe gefunden):]|"
        ausgabe += ewortptxt[0:-1] + "|\n"
        ausgabe += "|:blue[Buchstabenwert-Produkt:(Nullen werden ignoriert):]|"
        ausgabe += str(wortprodukt) + "|\n"
        return ausgabe

def buchstabenwert_zu_text(eingabetext):
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    bw = {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k',
          12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u',
          22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z', 27: 'ä', 28: 'ö', 29: 'ü', 30: 'ß'}
    
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.buchstabenwert_zu_text
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
            else:
                if ausz not in bw:
                    return ":red[Die eingegebene Zahl ist kein gültiger Buchstabenwert!]"
                else:
                    return bw[ausz]
        else:
            ausgabe_text = ""
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    if az in bw:
                        atxt = atxt + bw[az]
                    else:
                        ignor = ignor + str(z) + " "
            if ignor != "":
                ausgabe_text += ":red[Achtung folgendes wurde ignoriert:]  \n"
                ausgabe_text += ignor + "  \n \n"
            ausgabe_text += ":blue[umgewandelte Zeichen:]  \n"
            ausgabe_text += atxt
            return ausgabe_text

def zeichenkette_reverse(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.zeichenkette_reverse
    else:
        return eingabetext[::-1]

def zeichenanzahl(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.zeichenanzahl
    else:
        ausgabetext = ""
        anzahl = {}
        for b in eingabetext:
            if b in anzahl:
                anzahl[b] = anzahl[b] + 1
            else:
                anzahl[b] = 1
        s = []
        zeichensumme = 0
        for key in anzahl:
            s.append(key)
            zeichensumme += anzahl[key]
        s.sort()
        ausgabetext += (f"Es wurden __:orange[{len(anzahl)}]__ unterschiedliche Zeichen in insgesamt "
                        f"__:orange[{zeichensumme}]__ Zeichen gefunden.  \n"
                        f"| :blue[Zeichen] | :blue[Anzahl] |\n|----|----|\n")
        for i in s:
            if ord(i) == 9:
                ausgabetext += f"|TAB|{anzahl[i]}|\n"
            elif ord(i) == 32:
                ausgabetext += f"|SPACE|{anzahl[i]}|\n"
            elif ord(i) == 10:
                ausgabetext += f"|LINEFEED| = {anzahl[i]}|\n"
            else:
                ausgabetext += f"|{i}|{anzahl[i]}|\n"
        return ausgabetext

def quersummen(eingabetext):
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.quersummen
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
            else:
                return f" :blue[Quersumme:] {helper.q_sum(ausz)}  \n:blue[iterierte Quersumme:] {helper.iq_sum(ausz)}"
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            qtxt = ""
            iqtxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    qtxt = qtxt + str(helper.q_sum(az)) + "/"
                    iqtxt = iqtxt + str(helper.iq_sum(az)) + "/"
            if ignor != "":
                ausgabetext += ":red[Achtung nicht erkannte Zeichen:]  \n"
                ausgabetext += ignor + "  \n  \n"
            ausgabetext += ":blue[Quersummen:]  \n"
            ausgabetext += qtxt[:-1] + "  \n  \n"
            ausgabetext += ":blue[iterierte Quersummen]  \n"
            ausgabetext += iqtxt[:-1]
            return ausgabetext

def einschluss_count(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.einschluss_count
    else:
        bw = "ADOPQRabdegopq690"
        wortsummenliste_ohne = []
        wortsummenliste_mit = []
        wortliste = eingabetext.split()
        for wort in wortliste:
            wz_ohne = 0
            wz_mit = 0
            for b in wort:
                if b == "4":
                    wz_mit += 1
                if b == "B" or b == "8":
                    wz_ohne += 2
                    wz_mit += 2
                elif b in bw:
                    wz_mit += 1
                    wz_ohne += 1
            wortsummenliste_ohne.append(wz_ohne)
            wortsummenliste_mit.append(wz_mit)
        ausgabetext = "__:orange[mit 4]__  \n"
        ausgabetext += ":blue[insgesamt gefundene Einschlüsse:] "
        ausgabetext += f"{sum(wortsummenliste_mit)}  \n"
        ausgabetext += ":blue[Einschlüsse pro Wort:] "
        for z in wortsummenliste_mit:
            ausgabetext += f"{z} "
        ausgabetext += "  \n  \n"
        ausgabetext += "__:orange[ohne 4]__  \n"
        ausgabetext += ":blue[insgesamt gefundene Einschlüsse:] "
        ausgabetext += f"{sum(wortsummenliste_ohne)}  \n"
        ausgabetext += ":blue[Einschlüsse pro Wort:] "
        for z in wortsummenliste_ohne:
            ausgabetext += f"{z} "
        return ausgabetext

def morse_to_abc(eingabetext):
    alphabet = {".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E", "..-.": "F", "--.": "G", "....": "H",
                "..": "I", ".---": "J", "-.-": "K", ".-..": "L",
                "--": "M", "-.": "N", "---": "O", ".--.": "P", "--.-": "Q", ".-.": "R", "...": "S", "-": "T",
                "..-": "U", "...-": "V", ".--": "W", "-..-": "X", "-.--": "Y",
                "--..": "Z", ".----": "1", "..---": "2", "...--": "3", "....-": "4", ".....": "5", "-....": "6",
                "--...": "7", "---..": "8", "----.": "9", "-----": "0", "--.--": "Ñ",
                "..-..": "É", ".-..-": "È", ".--.-": "À", "..--": "Ü", "---.": "Ö", ".-.-": "Ä", "..--.-": "_",
                ".--.-.": "@", "..--..": "?", "-...-": "=", "-.-.-.": ";", "---...": ":",
                "-..-.": "/", ".-.-.-": ".", "-....-": "-", "--..--": ",", ".-.-.": "+", "-.--.-": ")", "-.--.": "(",
                ".----.": "'", "...--..": "ß"
                }
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.morse_to_abc
    else:
        morse = eingabetext.split()
        atxt = ""
        for sign in morse:
            if sign == "/":
                atxt = atxt + " "
            elif sign not in alphabet:
                atxt = atxt + ":red[#]"
            else:
                atxt = atxt + alphabet[sign]
        return atxt

def abc_to_morse(eingabetext):
    alphabet = {".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E", "..-.": "F", "--.": "G", "....": "H",
                "..": "I", ".---": "J", "-.-": "K", ".-..": "L",
                "--": "M", "-.": "N", "---": "O", ".--.": "P", "--.-": "Q", ".-.": "R", "...": "S", "-": "T",
                "..-": "U", "...-": "V", ".--": "W", "-..-": "X", "-.--": "Y",
                "--..": "Z", ".----": "1", "..---": "2", "...--": "3", "....-": "4", ".....": "5", "-....": "6",
                "--...": "7", "---..": "8", "----.": "9", "-----": "0", "--.--": "Ñ",
                "..-..": "É", ".-..-": "È", ".--.-": "À", "..--": "Ü", "---.": "Ö", ".-.-": "Ä", "..--.-": "_",
                ".--.-.": "@", "..--..": "?", "-...-": "=", "-.-.-.": ";", "---...": ":",
                "-..-.": "/", ".-.-.-": ".", "-....-": "-", "--..--": ",", ".-.-.": "+", "-.--.-": ")", "-.--.": "(",
                ".----.": "'", "...--..": "SS"
                }
    umkehr_alpha = {v: k for k, v in alphabet.items()}  # Alphabet mit getauschten key und values generieren
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.abc_to_morse
    else:
        atxt = ""
        for b in eingabetext:
            if b == " ":
                atxt = atxt + "/ "
            elif b.upper() not in umkehr_alpha:
                atxt = atxt + b + " "
            else:
                atxt = atxt + umkehr_alpha[b.upper()] + " "
        return atxt

def rot5(eingabetext):
    ro5 = {"0": "5", "1": "6", "2": "7", "3": "8", "4": "9", "5": "0", "6": "1", "7": "2", "8": "3", "9": "4"}
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.rot5
    else:
        atxt = ""
        for z in eingabetext:
            if z not in ro5:
                atxt = atxt + z
            else:
                atxt = atxt + ro5[z]
        return atxt

def rot13(eingabetext):
    ro13 = {'A': 'N', 'B': 'O', 'C': 'P', 'D': 'Q', 'E': 'R', 'F': 'S', 'G': 'T', 'H': 'U', 'I': 'V', 'J': 'W',
            'K': 'X', 'L': 'Y', 'M': 'Z',
            'N': 'A', 'O': 'B', 'P': 'C', 'Q': 'D', 'R': 'E', 'S': 'F', 'T': 'G', 'U': 'H', 'V': 'I', 'W': 'J',
            'X': 'K', 'Y': 'L', 'Z': 'M'}
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.rot13
    else:
        atxt = ""
        for z in eingabetext:
            if z.upper() not in ro13:
                atxt = atxt + z
            elif z.lower() == z:
                a = ro13[z.upper()]
                atxt = atxt + a.lower()
            else:
                atxt = atxt + ro13[z.upper()]
        return atxt

def rot18(eingabetext):
    ro18 = {'A': 'N', 'B': 'O', 'C': 'P', 'D': 'Q', 'E': 'R', 'F': 'S', 'G': 'T', 'H': 'U', 'I': 'V', 'J': 'W',
            'K': 'X', 'L': 'Y', 'M': 'Z',
            'N': 'A', 'O': 'B', 'P': 'C', 'Q': 'D', 'R': 'E', 'S': 'F', 'T': 'G', 'U': 'H', 'V': 'I', 'W': 'J',
            'X': 'K', 'Y': 'L', 'Z': 'M',
            "0": "5", "1": "6", "2": "7", "3": "8", "4": "9", "5": "0", "6": "1", "7": "2", "8": "3", "9": "4"}
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.rot18
    else:
        atxt = ""
        for z in eingabetext:
            if z.upper() not in ro18:
                atxt = atxt + z
            elif z.lower() == z:
                a = ro18[z.upper()]
                atxt = atxt + a.lower()
            else:
                atxt = atxt + ro18[z.upper()]
        return atxt

def rot47(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.rot47
    else:
        x = []
        for i in eingabetext:
            j = ord(i)
            if 33 <= j <= 126:
                x.append(chr(33 + ((j + 14) % 94)))
            else:
                x.append(i)
        return f"```\n{''.join(x)}\n```"

def ascii_to_dez(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.ascii_to_dez
    else:
        z = []
        for i in eingabetext:
            z.append(str(ord(i)))
        return ' '.join(z)

def dez_to_ascii(eingabetext):
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.dez_to_ascii
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
            else:
                return chr(ausz)
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    atxt = atxt + chr(az)
            if ignor != "":
                ausgabetext += ":red[Achtung nicht erkannte Zeichen:]  \n"
                ausgabetext += ignor + "  \n  \n"
            ausgabetext += ":blue[umgewandelte Zeichen:]  \n"
            ausgabetext += atxt
            return ausgabetext

def ascii_to_hex(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.ascii_to_hex
    else:
        z = []
        for i in eingabetext:
            hexstr = ("{:X}".format(ord(i)))  # großes X für Hex in Großbuchstaben
            z.append(hexstr)
        return ' '.join(z)

def hex_to_ascii(eingabetext):
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.hex_to_ascii
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 16)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
            else:
                return chr(ausz)
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z, 16)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    atxt = atxt + chr(az)
            if ignor != "":
                ausgabetext += ":red[Achtung nicht erkannte Zeichen]  \n"
                ausgabetext += ignor + "  \n  \n"
            ausgabetext += ":blue[umgewandelte Zeichen:]  \n"
            ausgabetext += atxt
            return ausgabetext

def ascii_to_octal(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.ascii_to_octal
    else:
        z = []
        for i in eingabetext:
            z.append("{:o}".format(ord(i)))
        return ' '.join(z)

def octal_to_ascii(eingabetext):
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.octal_to_ascii
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 8)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
            else:
                return chr(ausz)
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z, 8)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    atxt = atxt + chr(az)
            if ignor != "":
                ausgabetext += ":red[Achtung nicht erkannte Zeichen]  \n"
                ausgabetext += ignor + "  \n  \n"
            ausgabetext += ":blue[umgewandelte Zeichen:]  \n"
            ausgabetext += atxt
            return ausgabetext

def ascii_to_bin16(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.ascii_to_bin16
    else:
        z = []
        for i in eingabetext:
            z.append("{:0>16b}".format(ord(i)))
        return ' '.join(z)

def ascii_to_bin8(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.ascii_to_bin8
    else:
        z = []
        for i in eingabetext:
            if ord(i) > 255:
                return (":red[Sorry der Eingabetext enthält Zeichen,welche sich nicht mit 8 bit in binär darstellen "
                        "lassen!]")
            z.append("{:0>8b}".format(ord(i)))
        return ' '.join(z)

def bin_to_ascii(eingabetext):
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.bin_to_ascii
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 2)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
            else:
                return chr(ausz)
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z, 2)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    atxt = atxt + chr(az)
            if ignor != "":
                ausgabetext += ":red[Achtung nicht erkannte Zeichen]  \n"
                ausgabetext += ignor + "  \n  \n"
            ausgabetext += ":blue[umgewandelte Zeichen:]  \n"
            ausgabetext += atxt
            return ausgabetext

def zahlwortsuche_de(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.zahlwortsuche_de
    else:
        zahlen = ["null", "eins", "zwei", "drei", "vier", "fünf", "fuenf", "sechs", "sieben", "acht",
                  "neun", "zehn", "elf", "zwölf", "zwoelf", "zwanzig", "hundert", "tausend"]
        ntxt = ""
        abc = "abcdefghijklmnopqrstuvwxyzäöüß"
        for b in eingabetext:
            if b.lower() not in abc:
                continue
            ntxt = ntxt + b.lower()
        for z in zahlen:
            if z.lower() in ntxt:
                ntxt = ntxt.replace(z.lower(), "-" + z.upper() + "_")
        atxt = ""
        tt = False
        for b in ntxt:
            if b == "-":
                tt = True
                continue
            if b == "_":
                tt = False
                atxt = atxt + " "
            if tt:
                atxt = atxt + b
        if atxt == "":
            return ":red[Leider keine Zahlwörter gefunden!]"
        else:
            ausgabetext = ":blue[Gefundene Zahlwörter:]  \n"
            ausgabetext += atxt + "  \n  \n"
            ausgabetext += ":blue[Eingangstext:]  \n"
            ausgabetext += ntxt
            return ausgabetext

def zahlwortsuche_en(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.zahlwortsuche_en
    else:
        zahlen = ["eleven", "twelve", "thirteen", "fourteen", "fifteen", "fourty", "sixty", "seventy",
                  "eighty", "ninety", "zero", "one", "two", "three", "four", "five", "six", "seven",
                  "eight", "nine", "ten", "twenty", "thirty", "fifty"]
        ntxt = ""
        abc = "abcdefghijklmnopqrstuvwxyz"
        for b in eingabetext:
            if b.lower() not in abc:
                continue
            ntxt = ntxt + b.lower()
        for z in zahlen:
            if z.lower() in ntxt:
                ntxt = ntxt.replace(z.lower(), "-" + z.upper() + "_")
        atxt = ""
        tt = False
        for b in ntxt:
            if b == "-":
                tt = True
                continue
            if b == "_":
                tt = False
                atxt = atxt + " "
            if tt:
                atxt = atxt + b
        if atxt == "":
            return ":red[Leider keine Zahlwörter gefunden!]"
        else:
            ausgabetext = ":blue[Gefundene Zahlwörter:]  \n"
            ausgabetext += atxt + "  \n  \n"
            ausgabetext += ":blue[Eingangstext:]  \n"
            ausgabetext += ntxt
            return ausgabetext

def kenny_kodieren(eingabetext):
    alphabet = {"a": "mmm", "b": "mmp", "c": "mmf", "d": "mpm", "e": "mpp", "f": "mpf", "g": "mfm", "h": "mfp",
                "i": "mff", "j": "pmm", "k": "pmp",
                "l": "pmf", "m": "ppm", "n": "ppp", "o": "ppf", "p": "pfm", "q": "pfp", "r": "pff", "s": "fmm",
                "t": "fmp", "u": "fmf", "v": "fpm", "w": "fpp",
                "x": "fpf", "y": "ffm", "z": "ffp", "ä": "mmmmpp", "ö": "ppfmpp", "ü": "fmfmpp", "ß": "fmmfmm",
                "A": "Mmm", "B": "Mmp", "C": "Mmf", "D": "Mpm",
                "E": "Mpp", "F": "Mpf", "G": "Mfm", "H": "Mfp", "I": "Mff", "J": "Pmm", "K": "Pmp", "L": "Pmf",
                "M": "Ppm", "N": "Ppp", "O": "Ppf", "P": "Pfm",
                "Q": "Pfp", "R": "Pff", "S": "Fmm", "T": "Fmp", "U": "Fmf", "V": "Fpm", "W": "Fpp", "X": "Fpf",
                "Y": "Ffm", "Z": "Ffp", "Ä": "Mmmmpp",
                "Ö": "Ppfmpp", "Ü": "Fmfmpp"
                }
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.kenny_kodieren
    else:
        atxt = ""
        for b in eingabetext:
            if b in alphabet:
                atxt = atxt + alphabet[b]
            else:
                atxt = atxt + b
        return atxt

def kenny_dekodieren(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.kenny_dekodieren
    else:
        return helper.unkennify(eingabetext)

def kenny_raten(eingabetext):
    wbk = {"000": "a", "001": "b", "002": "c", "010": "d", "011": "e", "012": "f", "020": "g", "021": "h",
           "022": "i", "100": "j", "101": "k", "102": "l", "110": "m", "111": "n", "112": "o", "120": "p",
           "121": "q", "122": "r", "200": "s", "201": "t", "202": "u", "210": "v", "211": "w", "212": "x",
           "220": "y", "221": "z"
           }
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.kenny_raten
    else:
        wtxt = eingabetext.replace(chr(9),"").replace(chr(32),"").replace(chr(10),"").lower()
        # erstmal leerzeichen, tab, linefeed raus und alles klein
        anzahl = {}  # restliche zeichen zählen und in ein wörterbuch
        for c in wtxt:
            if c in anzahl:
                anzahl[c] = anzahl[c] + 1
            else:
                anzahl[c] = 1
        s = []  # zum Sortieren lieber eine liste
        for key in anzahl:
            s.append([anzahl[key], key])
        s.sort(reverse=True)
        abc3 = [s[0][1], s[1][1], s[2][1]]  # die 3 häufigsten Zeichen im Text wären gefunden
        cwtxt = ""
        for b in wtxt:  # alles raus außer den 3 häufigsten Zeichen
            if b not in abc3:
                continue
            cwtxt = cwtxt + b
        abca = ["a", "b", "c", "d"]  # falls 0,1,2 verwendet wurden in a, b, c... ändern
        if "0" in abc3 or "1" in abc3 or "2" in abc3:
            for i in range(3):
                if abc3[i] in ["0", "1", "2"]:
                    for j in abca:
                        if j in abc3:
                            continue
                        else:
                            cwtxt = cwtxt.replace(abc3[i], j)
                            abc3[i] = j
                            break
        ausgabetext = ""
        for p in helper.all_perms(abc3):
            txt0 = cwtxt.replace(p[0], "0")
            txt1 = txt0.replace(p[1], "1")
            txt2 = txt1.replace(p[2], "2")
            atxt = ""
            for i in range(0, len(txt2), 3):
                tri = txt2[i:i + 3]
                if tri in wbk:
                    atxt = atxt + wbk[tri]
            ausgabetext += f":blue[{p}]  \n"
            ausgabetext += f"{atxt}  \n  \n"
        return ausgabetext

def primzahlalphabet_dekodieren(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.primzahlalphabet_dekodieren
    else:
        grenze = 1000000
        primes = helper.primzahlliste(grenze)
        pdict = {}
        bz = 65
        for p in primes:
            if bz == 91:
                bz = 65
            pdict[p] = chr(bz)
            bz += 1
        seperator = ("|,", "_", ".", "-", "/", ";", ",")
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
            if se == "" and " " in eingabetext:
                se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
            else:
                if ausz in pdict:
                    return pdict[ausz]
                else:
                    return f":red[{eingabetext} ist keine Primzahl oder größer als 1 Million!]"
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    if az in pdict:
                        atxt = atxt + pdict[az]
                    else:
                        ignor = ignor + str(z) + " "
            if ignor != "":
                ausgabetext += ":red[ignoriert wurde:]  \n"
                ausgabetext += ignor + "  \n  \n"
            ausgabetext += ":blue[umgewandelte Zahlen:]  \n"
            ausgabetext += atxt
            return ausgabetext

def primzahlpruefen(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.primzahlpruefen
    else:
        try:
            ausz = int(eingabetext)
        except ValueError:
            return ":red[Keine Zahl erkannt!]"
        else:
            if ausz > 1299709:
                return (":red[Sorry, aber ich mag nur die ersten 100,000 Primzahlen, das sind Zahlen bis maximal "
                        "1,299,709 !]")
            primes = helper.primzahlliste(1299710)
            if ausz not in primes:
                return f":orange[{ausz:,}] ist keine Primzahl"
            else:
                return f":orange[{ausz:,}] ist die :orange[{primes.index(ausz) + 1:,}.] Primzahl"

def nte_primzahl(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.nte_primzahl
    else:
        try:
            ausz = int(eingabetext)
        except ValueError:
            return ":red[Keine Zahl erkannt!]"
        if ausz > 100000:
            return ":red[Sorry, aber ich mag nur die ersten 100,000 Primzahlen, das sind Zahlen bis maximal 1,299,709 !]"
        else:
            primes = helper.primzahlliste(1299710)
            return f"Die :orange[{ausz:,}.] Primzahl lautet: :orange[{primes[ausz - 1]:,}]"

def primfaktoren(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.primfaktoren
    else:
        try:
            n = int(eingabetext)
        except ValueError:
            return ":red[Es konnte leider keine Zahl erkannt werden.]"
        faktoren = []
        for i in chain([2], range(3, n // 2 + 1, 2)):
            if i > 100000000:
                return (":red[Sorry, aber die Primfaktorensuche wurde abgebrochen, da mindestens 1 Faktor größer als "
                        "100 Millionen ist.]")
            while n % i == 0:
                faktoren.append(i)
                n = n // i
            if i > n:
                break
        out = f"_Die Zahl :orange[{eingabetext}] hat folgende Primfaktoren:_  \n"
        if not faktoren:
            return f"Die Zahl :orange[{eingabetext}] ist eine Primzahl!!"
        else:
            for z in faktoren:
                out += str(z) + ", "
        return out[:-2]

def dez_to_hex_oct_bin(eingabetext):
    seperator = ("|,", "_", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.dez_to_hex_oct_bin
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
            else:
                return ":blue[DEZ:] {0:}  \n:blue[HEX:] {0:X}  \n:blue[OCT:] {0:o}  \n:blue[BIN:] {0:b}".format(ausz)
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    deztxt = deztxt + str(az) + "/"
                    hextxt = hextxt + "{:X}".format(az) + "/"
                    octtxt = octtxt + "{:o}".format(az) + "/"
                    bintxt = bintxt + "{:b}".format(az) + "/"
            if ignor != "":
                ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor}  \n"
            ausgabetext += f":blue[DEZ:] {deztxt[:-1]}  \n"
            ausgabetext += f":blue[HEX:] {hextxt[:-1]}  \n"
            ausgabetext += f":blue[OCT:] {octtxt[:-1]}  \n"
            ausgabetext += f":blue[BIN:] {bintxt[:-1]}  \n"
            return ausgabetext

def hex_to_dez_oct_bin(eingabetext):
    seperator = ("|,", "_", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.hex_to_dez_oct_bin
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 16)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
            else:
                return ":blue[HEX:] {0:X}  \n:blue[DEZ:] {0:}  \n:blue[OCT:] {0:o}  \n:blue[BIN:] {0:b}".format(ausz)
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
            for z in txt:
                try:
                    az = int(z, 16)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    deztxt = deztxt + str(az) + "/"
                    hextxt = hextxt + "{:X}".format(az) + "/"
                    octtxt = octtxt + "{:o}".format(az) + "/"
                    bintxt = bintxt + "{:b}".format(az) + "/"
            if ignor != "":
                ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor}  \n"
            ausgabetext += f":blue[HEX:] {hextxt[:-1]}  \n"
            ausgabetext += f":blue[DEZ:] {deztxt[:-1]}  \n"
            ausgabetext += f":blue[OCT:] {octtxt[:-1]}  \n"
            ausgabetext += f":blue[BIN:] {bintxt[:-1]}  \n"
            return ausgabetext

def oct_to_hex_dez_bin(eingabetext):
    seperator = ("|,", "_", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.oct_to_hex_dez_bin
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 8)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
            else:
                return ":blue[OCT:] {0:o}  \n:blue[HEX:] {0:X}  \n:blue[DEZ:] {0:}  \n:blue[BIN:] {0:b}".format(ausz)
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
            for z in txt:
                try:
                    az = int(z, 8)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    deztxt = deztxt + str(az) + "/"
                    hextxt = hextxt + "{:X}".format(az) + "/"
                    octtxt = octtxt + "{:o}".format(az) + "/"
                    bintxt = bintxt + "{:b}".format(az) + "/"
            if ignor != "":
                ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor}  \n"
            ausgabetext += f":blue[OCT:] {octtxt[:-1]}  \n"
            ausgabetext += f":blue[HEX:] {hextxt[:-1]}  \n"
            ausgabetext += f":blue[DEZ:] {deztxt[:-1]}  \n"
            ausgabetext += f":blue[BIN:] {bintxt[:-1]}  \n"
            return ausgabetext

def bin_to_hex_dez_oct(eingabetext):
    seperator = ("|,", "_", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.bin_to_hex_dez_oct
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 2)
            except ValueError:
                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
            else:
                return ":blue[BIN:] {0:b}  \n:blue[HEX:] {0:X}  \n:blue[DEZ:] {0:}  \n:blue[OCT:] {0:o}".format(ausz)
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
            for z in txt:
                try:
                    az = int(z, 2)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    deztxt = deztxt + str(az) + "/"
                    hextxt = hextxt + "{:X}".format(az) + "/"
                    octtxt = octtxt + "{:o}".format(az) + "/"
                    bintxt = bintxt + "{:b}".format(az) + "/"
            if ignor != "":
                ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor}  \n"
            ausgabetext += f":blue[BIN:] {bintxt[:-1]}  \n"
            ausgabetext += f":blue[HEX:] {hextxt[:-1]}  \n"
            ausgabetext += f":blue[DEZ:] {deztxt[:-1]}  \n"
            ausgabetext += f":blue[OCT:] {octtxt[:-1]}  \n"
            return ausgabetext

def abc_to_tomtom(eingabetext):
    alphabet = {"a": "/ ", "b": "// ", "c": "/// ", "d": "//// ", "e": "/\\\\ ", "f": "//\\\\ ", "g": "///\\\\ ",
                "h": "/\\\\\\\\ ", "i": "/\\\\\\\\\\ ", "j": "\\\\/ ", "k": "\\\\\\\\/ ", "l": "\\\\\\\\\\\\/ ",
                "m": "\\\\// ", "n": "\\\\/// ", "o": "/\\\\/ ", "p": "//\\\\/ ", "q": "/\\\\\\\\/ ", "r": "/\\\\// ",
                "s": "\\\\/\\\\ ", "t": "\\\\\\\\/\\\\ ", "u": "\\\\//\\\\ ", "v": "\\\\/\\\\\\\\ ", "w": "//\\\\\\\\ ",
                "x": "\\\\\\\\// ", "y": "\\\\/\\\\/ ", "z": "/\\\\/\\\\ "
                }  # schräg aber wir brauchen zum kodieren doppel-doppelte backslashs damit die Ausgabe im Browser passt
    if eingabetext == "":
        return hilfetexte.abc_to_tomtom
    else:
        ausgabetext = ""
        atxt = ""
        ignor = ""
        for b in eingabetext:
            if b == " ":
                atxt = atxt + "  "
            elif b.lower() not in alphabet:
                ignor = ignor + b + " "
            else:
                atxt = atxt + alphabet[b.lower()]
        if ignor != "":
            ausgabetext += ":red[ignorierte Zeichen:]  \n"
            ausgabetext += ignor + "  \n  \n"
        ausgabetext += ":blue[kodierter Text:]  \n"
        ausgabetext += atxt
        return ausgabetext

def tomtom_to_abc(eingabetext):
    alphabet = {'/': 'A', '//': 'B', '///': 'C', '////': 'D', '/\\': 'E', '//\\': 'F', '///\\': 'G', '/\\\\': 'H',
                '/\\\\\\': 'I', '\\/': 'J',
                '\\\\/': 'K', '\\\\\\/': 'L', '\\//': 'M', '\\///': 'N', '/\\/': 'O', '//\\/': 'P', '/\\\\/': 'Q',
                '/\\//': 'R', '\\/\\': 'S',
                '\\\\/\\': 'T', '\\//\\': 'U', '\\/\\\\': 'V', '//\\\\': 'W', '\\\\//': 'X', '\\/\\/': 'Y',
                '/\\/\\': 'Z'
                }  # schräg aber wir brauchen zum kodieren doppel-doppelte backslashs damit die Ausgabe im Browser passt
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.tomtom_to_abc
    else:
        tomtom = eingabetext.replace("  ", " _ ")
        tomtom = tomtom.split()
        atxt = ""
        for sign in tomtom:
            if sign == "_":
                atxt = atxt + " "
            elif sign not in alphabet:
                atxt = atxt + "#"
            else:
                atxt = atxt + alphabet[sign]
        return atxt

def text_to_slashpipe(eingabetext):
    alphabet = {"a": "| ", "b": "|\\\\ ", "c": "|| ", "d": "|/ ", "e": "\\\\ ", "f": "||\\\\ ", "g": "||| ",
                "h": "\\\\\\\\ ", "i": "/ ", "j": "|\\\\\\\\ ", "k": "//|| ", "l": "|\\\\/ ", "m": "|\\\\| ",
                "n": "|/| ", "o": "||/| ", "p": "|\\\\|\\\\ ", "q": "/\\\\ ", "r": "\\\\/ ", "s": "/| ", "t": "|// ",
                "u": "// ", "v": "||\\\\\\\\ ", "w": "\\\\/|| ",
                "x": "||/ ", "y": "|||\\\\ ", "z": "|||| "
                }  # jweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.text_to_slashpipe
    else:
        ausgabetext = ""
        atxt = ""
        ignor = ""
        for b in eingabetext:
            if b == " ":
                atxt = atxt + "  "
            elif b.lower() not in alphabet:
                ignor = ignor + b + " "
            else:
                atxt = atxt + alphabet[b.lower()]
        if ignor != "":
            ausgabetext += ":red[ignorierte Zeichen:]  \n"
            ausgabetext += ignor + "  \n  \n"
        ausgabetext += ":blue[kodierter Text:]  \n"
        ausgabetext += atxt
        return ausgabetext

def slashpipe_to_text(eingabetext):
    alphabet = {'|': 'A', '|\\': 'B', '||': 'C', '|/': 'D', '\\': 'E', '||\\': 'F', '|||': 'G', '\\\\': 'H', '/': 'I',
                '|\\\\': 'J', '//||': 'K', '|\\/': 'L', '|\\|': 'M', '|/|': 'N', '||/|': 'O', '|\\|\\': 'P', '/\\': 'Q',
                '\\/': 'R',
                '/|': 'S', '|//': 'T', '//': 'U', '||\\\\': 'V', '\\/||': 'W', '||/': 'X', '|||\\': 'Y', '||||': 'Z'}
    # jeweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.slashpipe_to_text
    else:
        tomtom = eingabetext.replace("  ", " _ ")
        tomtom = tomtom.split()
        atxt = ""
        for sign in tomtom:
            if sign == "_":
                atxt = atxt + " "
            elif sign not in alphabet:
                atxt = atxt + "#"
            else:
                atxt = atxt + alphabet[sign]
        return atxt

def periodensystem(eingabetext):
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    pse = {1: "H", 2: "He", 3: "Li", 4: "Be", 5: "B", 6: "C", 7: "N", 8: "O", 9: "F", 10: "Ne", 11: "Na", 12: "Mg",
           13: "Al",
           14: "Si", 15: "P", 16: "S", 17: "Cl", 18: "Ar", 19: "K", 20: "Ca", 21: "Sc", 22: "Ti", 23: "V", 24: "Cr",
           25: "Mn",
           26: "Fe", 27: "Co", 28: "Ni", 29: "Cu", 30: "Zn", 31: "Ga", 32: "Ge", 33: "As", 34: "Se", 35: "Br", 36: "Kr",
           37: "Rb", 38: "Sr", 39: "Y", 40: "Zr", 41: "Nb", 42: "Mo", 43: "Tc", 44: "Ru", 45: "Rh", 46: "Pd", 47: "Ag",
           48: "Cd", 49: "In", 50: "Sn", 51: "Sb", 52: "Te", 53: "I", 54: "Xe", 55: "Cs", 56: "Ba", 57: "La", 58: "Ce",
           59: "Pr", 60: "Nd", 61: "Pm", 62: "Sm", 63: "Eu", 64: "Gd", 65: "Tb", 66: "Dy", 67: "Ho", 68: "Er", 69: "Tm",
           70: "Yb", 71: "Lu", 72: "Hf", 73: "Ta", 74: "W", 75: "Re", 76: "Os", 77: "Ir", 78: "Pt", 79: "Au", 80: "Hg",
           81: "Tl", 82: "Pb", 83: "Bi", 84: "Po", 85: "At", 86: "Rn", 87: "Fr", 88: "Ra", 89: "Ac", 90: "Th", 91: "Pa",
           92: "U", 93: "Np", 94: "Pu", 95: "Am", 96: "Cm", 97: "Bk", 98: "Cf", 99: "Es", 100: "Fm", 101: "Md",
           102: "No",
           103: "Lr", 104: "Rf", 105: "Db", 106: "Sg", 107: "Bh", 108: "Hs", 109: "Mt", 110: "Ds", 111: "Rg", 112: "Cn",
           113: "Nh", 114: "Fl", 115: "Mc", 116: "Lv", 117: "Ts", 118: "Og"}
    um_pse = {v: k for k, v in pse.items()}
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.periodensystem
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                if eingabetext in um_pse:
                    return str(um_pse[eingabetext])
                else:
                    return ":red[Keine gültige Eingabe erkannt!]"
            else:
                return pse[ausz]
        else:
            ausgabetext = ""
            txt = eingabetext.split(se)
            atxt = ""
            atxt2 = ""
            atxt3 = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    if z in um_pse:
                        atxt3 += f"|{z}|{str(um_pse[z])}|\n"
                    else:
                        ignor = ignor + z + " "
                else:
                    if az in pse:
                        atxt = atxt + pse[az] + " "
                        atxt2 = atxt2 + pse[az][0]
                    else:
                        ignor = ignor + z + " "
            if ignor != "":
                ausgabetext += ":red[Achtung nicht erkannte Zeichen]  \n" + ignor + "  \n  \n"
            if atxt != "":
                ausgabetext += ":blue[Symbole:]  \n" + atxt + "  \n  \n"
            if atxt2 != "":
                ausgabetext += ":blue[Nur Anfangsbuchstaben:]  \n" + atxt2 + "  \n  \n"
            if atxt3 != "":
                ausgabetext += "|:blue[Symbol]|:blue[Ordnungszahl]|\n|-|-|\n" + atxt3
            return ausgabetext

def naknak_to_text(eingabetext):
    nakwb = {"Nak": "0", "Naknak": "6", "nanak": "B", "Nanak": "1", "Naknaknak": "7", "naknak": "C", "Nananak": "2",
             "Nak.": "8", "nak!": "D", "Nanananak": "3", "Naknak.": "9", "nak.": "E", "Nak?": "4", "Naknaknaknak": "A",
             "naknaknak": "F", "nak?": "5"}
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.naknak_to_text
    else:
        txt = eingabetext.split()
        utxt = ""
        z = 1
        for nak in txt:
            if nak in nakwb and z == 1:
                utxt = utxt + "%" + nakwb[nak]
                z += 1
            elif nak in nakwb:
                utxt = utxt + nakwb[nak]
                z = 1
        atxt = urllib_parse_unquote(utxt)
        return  f":blue[dekodiertes Geschnatter:]  \n{atxt}"

def navajo_to_text(eingabetext):
    nabc = {"WOL-LA-CHEE": "A", "BE-LA-SANA": "A", "TSE-NILL": "A", "NA-HASH-CHID": "B", "SHUSH": "B", "TOISH-JEH": "B",
            "MOASI": "C", "TLA-GIN": "C", "BA-GOSHI": "C", "BE": "D", "CHINDI": "D", "LHA-CHA-EH": "D", "AH-JAH": "E",
            "DZEH": "E", "AH-NAH": "E", "CHUO": "F", "TSA-E-DONIN-EE": "F", "MA-E": "F", "AH-TAD": "G", "KLIZZIE": "G",
            "JEHA": "G", "TSE-GAH": "H", "CHA": "H", "LIN": "H", "TKIN": "I", "YEH-HES": "I", "A-CHI": "I",
            "TKELE-CHO-G": "J", "TKELE-CHO-GI": "J", "AH-YA-TSINNE": "J", "YIL-DOI": "J", "JAD-HO-LONI": "K",
            "BA-AH-NE-DI-TININ": "K", "KLIZZIE-YAZZIE": "K", "DIBEH-YAZZIE": "L", "AH-JAD": "L", "NASH-DOIE-TSO": "L",
            "TSIN-TLITI": "M", "BE-TAS-TNI": "M", "NA-AS-TSO-SI": "M", "TSAH": "N", "A-CHIN": "N", "NESH-CHEE": "N",
            "A-KHA": "O", "TLO-CHIN": "O", "NE-AHS-JAH": "O", "NE-ASH-JAH": "O", "CLA-GI-AIH": "P", "BI-SO-DIH": "P",
            "BI-SODIH": "P", "NE-ZHONI": "P", "CA-YEILTH": "Q", "GAH": "R", "DAH-NES-TSA": "R", "AH-LOSZ": "R",
            "DIBEH": "S", "KLESH": "S", "D-AH": "T", "A-WOH": "T", "THAN-ZIE": "T", "SHI-DA": "U", "NO-DA-IH": "U",
            "A-KEH-DI-GLINI": "V", "GLOE-IH": "W", "AL-NA-AS-DZOH": "X", "AL-AN-AS-DZOH": "X", "TSAH-AS-ZIH": "Y",
            "BESH-DO-TLIZ": "Z", "BESH-DO-GLIZ": "Z", "BE-TKAH": " "}
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.navajo_to_text
    else:
        txt = eingabetext.split()
        atxt = ""
        for wort in txt:
            w = wort.upper()
            if w in nabc:
                atxt = atxt + nabc[w]
        return ":blue[dekodierter Text:]  \n" + atxt

def pi_suche(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.pi_suche
    else:
        try:
            piread = open("./data/pi.txt", "r")
        except FileNotFoundError:
            return ":red[Sorry es scheint die Datei pi.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
        else:
            pistr = ""
            for zeile in piread:
                pistr = pistr + zeile.rstrip()
            piread.close()
            pilen = len(pistr) - 2
            try:
                zahlx = int(eingabetext)
            except ValueError:
                return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
            else:
                ausgabetext = ":blue[PI (Kreiszahl)]  \n  \n"
                pos = pistr.find(eingabetext)
                if pilen >= zahlx > 0:
                    ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{pistr[zahlx + 1]}]  \n"
                                    f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
                                    f":orange[{pistr[zahlx + 1:zahlx + 21]}...]  \n  \n")
                else:
                    ausgabetext += f"Die verwendete pi.txt kennt leider nur :orange[{pilen:,}] Nachkommstellen.  \n  \n"
                if pos == -1:
                    ausgabetext += f"Zahlenreihe in :orange[{pilen:,}] Nachkommastellen nicht zu finden."
                else:
                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
                                    f':orange[{pos - 1}.] Nachkommastelle  \n20 Stellen ab :orange[{pos - 1}.] '
                                    f'Nachkommstelle: :orange[{pistr[pos:pos + 20]}...]')
                return ausgabetext

def euler_suche(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.euler_suche
    else:
        try:
            eread = open("./data/e.txt", "r")
        except FileNotFoundError:
            return ":red[Sorry es scheint die Datei e.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
        else:
            estr = ""
            for zeile in eread:
                estr = estr + zeile.rstrip()
            eread.close()
            elen = len(estr) - 2
            try:
                zahlx = int(eingabetext)
            except ValueError:
                return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
            else:
                ausgabetext = ":blue[e (Eulersche Zahl)]  \n  \n"
                pos = estr.find(eingabetext)
                if elen >= zahlx > 0:
                    ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{estr[zahlx + 1]}]  \n"
                                    f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
                                    f":orange[{estr[zahlx + 1:zahlx + 21]}...]  \n  \n")
                else:
                    ausgabetext += f"Die verwendete e.txt kennt leider nur :orange[{elen:,}] Nachkommstellen.  \n  \n"
                if pos == -1:
                    ausgabetext += f"Zahlenreihe in :orange[{elen:,}] Nachkommastellen nicht zu finden."
                else:
                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
                                    f':orange[{pos - 1}.] Nachkommastelle  \n20 Stellen ab :orange[{pos - 1}.] '
                                    f'Nachkommstelle: :orange[{estr[pos:pos + 20]}...]')
                return ausgabetext

def goldener_schnitt_suche(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.goldener_schnitt_suche
    else:
        try:
            phiread = open("./data/phi.txt", "r")
        except ValueError:
            return ":red[Sorry es scheint die Datei phi.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
        else:
            phistr = ""
            for zeile in phiread:
                phistr = phistr + zeile.rstrip()
            phiread.close()
            philen = len(phistr) - 2
            try:
                zahlx = int(eingabetext)
            except ValueError:
                return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
            else:
                ausgabetext = ":blue[phi (Goldener Schnitt)]  \n  \n"
                pos = phistr.find(eingabetext)
                if philen >= zahlx > 0:
                    ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{phistr[zahlx + 1]}]  \n"
                                    f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
                                    f":orange[{phistr[zahlx + 1:zahlx + 21]}...]  \n  \n")
                else:
                    ausgabetext += (f"Die verwendete pi.txt kennt leider nur :orange[{philen:,}] "
                                    f"Nachkommstellen.  \n  \n")
                if pos == -1:
                    ausgabetext += f"Zahlenreihe in :orange[{philen:,}] Nachkommastellen nicht zu finden."
                else:
                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
                                    f':orange[{pos - 1}.] Nachkommastelle  \n20 Stellen ab :orange[{pos - 1}.] '
                                    f'Nachkommstelle: :orange[{phistr[pos:pos + 20]}...]')
                return ausgabetext

def anagramm_suche_de(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.anagramm_suche_de
    else:
        try:
            wbfile = open("./data/german.dic", "r",
                          encoding="iso-8859-15")  # german.dic von https://sourceforge.net/projects/germandict/
        except FileNotFoundError:
            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
        else:
            eingabezaehl = helper.wortzaehl(eingabetext)
            ausgabetext = ":blue[gefundene Anagramme:]  \n"
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                if eingabetext.upper() == zeile.upper():
                    continue
                if len(eingabetext) != len(zeile):
                    continue
                if eingabezaehl == helper.wortzaehl(zeile):
                    ausgabetext += zeile + "  \n"
            wbfile.close()
            return ausgabetext

def anagramm_suche_en(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.anagramm_suche_en
    else:
        try:
            wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
        except FileNotFoundError:
            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
        else:
            eingabezaehl = helper.wortzaehl(eingabetext)
            ausgabetext = ":blue[gefundene Anagramme:]  \n"
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                if eingabetext.upper() == zeile.upper():
                    continue
                if len(eingabetext) != len(zeile):
                    continue
                if eingabezaehl == helper.wortzaehl(zeile):
                    ausgabetext += zeile + "  \n"
            wbfile.close()
            return ausgabetext

def wortsuche_de(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.wortsuche_de
    else:
        try:
            wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
        except FileNotFoundError:
            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
        else:
            ausgabetext = ":blue[im Wörterbuch gefundene passende Wörter:]  \n"
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                if len(eingabetext) != len(zeile):
                    continue
                fehler = 0
                for c in range(len(eingabetext)):
                    if eingabetext[c] == "*":
                        continue
                    if eingabetext[c].upper() != zeile[c].upper():
                        fehler += 1
                if fehler == 0:
                    ausgabetext += zeile + "  \n"
            wbfile.close()
            return ausgabetext

def wortsuche_en(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.wortsuche_en
    else:
        try:
            wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
        except FileNotFoundError:
            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
        else:
            ausgabetext = ":blue[im Wörterbuch gefundene passende Wörter:]  \n"
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                if len(eingabetext) != len(zeile):
                    continue
                fehler = 0
                for c in range(len(eingabetext)):
                    if eingabetext[c] == "*":
                        continue
                    if eingabetext[c].upper() != zeile[c].upper():
                        fehler += 1
                if fehler == 0:
                    ausgabetext += zeile + "  \n"
            wbfile.close()
            return ausgabetext

def remorse_de(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.remorse_de
    else:
        wbfile = open("./data/morse-de.dic", "r", encoding="iso-8859-15")
        ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:]  \n"
        count = 0
        for zeile in wbfile:
            zeile = zeile.strip(" \t\n\r")
            mline = zeile.split(",")
            if eingabetext == mline[0]:
                ausgabetext += mline[1] + "  \n"
                count += 1
        wbfile.close()
        if count == 0:
            return ":red[leider nichts gefunden :disappointed:]"
        else:
            return ausgabetext

def remorse_en(eingabetext):
    alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
                'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
                'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
                'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
                '2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
                '8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
                'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
                '?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
                '.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
                '(': '-.--.', "'": '.----.', 'SS': '...--..'}
    ualphabet = {v: k for k, v in alphabet.items()}
    ualphabet["...--.."] = "ß"
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.remorse_en
    else:
        try:
            wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
        except FileNotFoundError:
            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
        else:
            ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:]  \n"
            if eingabetext in ualphabet:
                ausgabetext += ualphabet[eingabetext] + "  \n"
            count = 0
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                mzeile = ""
                try:
                    for char in zeile:
                        mzeile += alphabet[char.upper()]
                except KeyError:
                    continue
                if eingabetext == mzeile:
                    ausgabetext += zeile + "  \n"
                    count += 1
            wbfile.close()
            if count == 0:
                return ":red[leider nichts gefunden :disappointed:]"
            else:
                return ausgabetext

def t9_de(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.t9_de
    else:
        wbfile = open("./data/t9-de.dic", "r", encoding="iso-8859-15")
        ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:]  \n"
        count = 0
        for zeile in wbfile:
            zeile = zeile.strip(" \t\n\r")
            mline = zeile.split(",")
            if eingabetext == mline[0]:
                ausgabetext += mline[1] + "  \n"
                count += 1
        wbfile.close()
        if count == 0:
            return ":red[leider nichts gefunden :disappointed:]"
        else:
            return ausgabetext

def t9_en(eingabetext):
    alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
                'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
                'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
                'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
                '3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
                '0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
                'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
                '-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.t9_en
    else:
        try:
            wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
        except FileNotFoundError:
            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
        else:
            ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:]  \n"
            count = 0
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                mzeile = ""
                try:
                    for char in zeile:
                        mzeile += alphabet[char.upper()]
                except KeyError:
                    continue
                if eingabetext == mzeile:
                    ausgabetext += zeile + "  \n"
                    count += 1
            wbfile.close()
            if count == 0:
                return ":red[leider nichts gefunden :disappointed:]"
            else:
                return ausgabetext

def vigenere(eingabetext, pw):
    bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12, 'M': 13,
          'N': 14,
          'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25, 'Z': 26}
    ubw = {v: k for k, v in bw.items()}
    if pw is None:
        return hilfetexte.vigenere
    pw = pw.strip()
    text = eingabetext.rstrip()
    if text == "" or pw == "":
        return hilfetexte.vigenere
    else:
        for b in pw:
            if b.upper() not in bw:
                return ":red[Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!]"
        pwl = len(pw)
        encoded_text = ""
        encoded_text_s = ""  # wenn Leer und Sonderzeichen Schlüsselbuchstaben verbrauchen
        auslz = 0  # auslasszähler zählt zeichen die im text nicht codiert wurden
        for i in range(len(text)):
            if text[i].upper() not in bw:
                encoded_text += text[i]
                auslz += 1
                encoded_text_s += text[i]
            else:
                b1 = bw[text[i].upper()]
                b2 = bw[pw[(i - auslz) % pwl].upper()]
                b2s = bw[pw[i % pwl].upper()]
                ba = (b1 + b2 - 1) % 26
                bas = (b1 + b2s - 1) % 26
                if ba == 0:
                    ba = 26
                if bas == 0:
                    bas = 26
                if text[i] == text[i].upper():
                    encoded_text += ubw[ba]
                    encoded_text_s += ubw[bas]
                else:
                    encoded_text += ubw[ba].lower()
                    encoded_text_s += ubw[bas].lower()
        decoded_text = ""
        decoded_text_s = ""
        auslz = 0  # auslasszähler zählt zeichen die im text nicht codiert wurden
        for i in range(len(text)):
            if text[i].upper() not in bw:
                decoded_text += text[i]
                auslz += 1
                decoded_text_s += text[i]
            else:
                b1 = bw[text[i].upper()]
                b2 = bw[pw[(i - auslz) % pwl].upper()]
                b2s = bw[pw[i % pwl].upper()]
                ba = (b1 - b2 + 1) % 26
                bas = (b1 - b2s + 1) % 26
                if ba == 0:
                    ba = 26
                if bas == 0:
                    bas = 26
                if text[i] == text[i].upper():
                    decoded_text += ubw[ba]
                    decoded_text_s += ubw[bas]
                else:
                    decoded_text += ubw[ba].lower()
                    decoded_text_s += ubw[bas].lower()
        ausgabetext = (f":blue[Dekodiert - normal:]  \n{decoded_text}  \n  \n"
                       f":blue[Kodiert - normal:]  \n{encoded_text}  \n  \n"
                       f":blue[Dekodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:]  \n{decoded_text_s}  \n  \n"
                       f":blue[Kodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:]  \n{encoded_text_s}")
        return ausgabetext

def wolseley(eingabetext, pw):
    abc = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird als i chiffriert
    if pw is None:
        return hilfetexte.wolseley
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "" or pw == "":
        return hilfetexte.wolseley
    else:
        for b in pw:
            if b.upper() not in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
                return ":red[Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!]"
        text = text.upper()
        pw = pw.upper()
        if "J" in text:
            text = text.replace("J", "I")
        if "J" in pw:
            pw = pw.replace("J", "I")
        calpha = ""
        for b in pw:
            if b not in calpha:
                calpha += b
        for b in abc:
            if b not in calpha:
                calpha += b
        cabc = {calpha[12]: calpha[12]}
        c1 = calpha[:12]
        c2 = calpha[13:]
        c2 = c2[::-1]
        for i in range(12):
            cabc[c1[i]] = c2[i]
        ucabc = {v: k for k, v in cabc.items()}
        cabc.update(ucabc)
        atxt = ""
        for b in text:
            if b in cabc:
                atxt += cabc[b]
            else:
                atxt += b
        return atxt

def atbash(eingabetext):
    text = eingabetext.rstrip()
    if text == "":
        return hilfetexte.atbash
    else:
        abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        uabc = abc[::-1]
        cabc = {}
        for i in range(26):
            cabc[abc[i]] = uabc[i]
        atxt = ""
        for b in text:
            if b.upper() in cabc:
                if b == b.upper():
                    atxt += cabc[b]
                else:
                    atxt += cabc[b.upper()].lower()
            else:
                atxt += b
        return atxt

def monoalphasubstitution(eingabetext, pw):
    if pw is None:
        return hilfetexte.monoalphasubstitution
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "" or pw == "":
        return hilfetexte.monoalphasubstitution
    else:
        abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        for b in pw:
            if b.upper() not in abc:
                return ":red[Das Schlüsselwort/Schlüsselalphabet darf nur die Buchstaben A-Z / a-z enthalten!]"
        cabc = ""
        for b in pw.upper() + abc:
            if b not in cabc:
                cabc += b
        cab = {}
        for i in range(26):
            cab[abc[i]] = cabc[i]
        ucab = {v: k for k, v in cab.items()}
        encoded_txt = ""
        for b in text:
            if b.upper() in cab:
                if b == b.upper():
                    encoded_txt += cab[b]
                else:
                    encoded_txt += cab[b.upper()].lower()
            else:
                encoded_txt += b
        decoded_txt = ""
        for b in text:
            if b.upper() in ucab:
                if b == b.upper():
                    decoded_txt += ucab[b]
                else:
                    decoded_txt += ucab[b.upper()].lower()
            else:
                decoded_txt += b
        ausgabetext = f":blue[Dekodiert:]  \n{decoded_txt}  \n  \n"
        ausgabetext += f":blue[Kodiert:]  \n{encoded_txt}  \n  \n"
        if len(pw) < len(abc):
            ausgabetext += f":blue[Schlüsselalphabet wurde wie folgt aufgefüllt:] {cabc}"
        return ausgabetext

def autokey(eingabetext, pw):
    if pw is None:
        return hilfetexte.autokey
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "" or pw == "":
        return  hilfetexte.autokey
    else:
        bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12,
              'M': 13, 'N': 14,
              'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25,
              'Z': 26}
        ubw = {v: k for k, v in bw.items()}
        p_we = ""
        p_wd = ""
        for b in pw:
            if b.upper() not in bw:
                return ":red[Das Schlüsselwort darf nur die Buchstaben A-Z / a-z enthalten!]"
            else:
                p_we += b.upper()  # Sonderzeichen aus PW entfernen und
                p_wd += b.upper()
        if len(p_we) < len(text):
            for b in text:
                if b.upper() in bw:
                    p_we += b.upper()
        encoded_text = ""
        auslz = 0  # auslasszähler zählt zeichen die im text nicht codiert wurden
        for i in range(len(text)):
            if text[i].upper() not in bw:
                encoded_text += text[i]
                auslz += 1
            else:
                b1 = bw[text[i].upper()]
                b2 = bw[p_we[(i - auslz)]]
                ba = (b1 + b2 - 1) % 26
                if ba == 0:
                    ba = 26
                if text[i] == text[i].upper():
                    encoded_text += ubw[ba]
                else:
                    encoded_text += ubw[ba].lower()
        decoded_text = ""
        auslz = 0
        for i in range(len(text)):
            if text[i].upper() not in bw:
                decoded_text += text[i]
                auslz += 1
            else:
                b1 = bw[text[i].upper()]
                b2 = bw[p_wd[(i - auslz)].upper()]
                ba = (b1 - b2 + 1) % 26
                if ba == 0:
                    ba = 26
                p_wd += ubw[ba]
                if text[i] == text[i].upper():
                    decoded_text += ubw[ba]
                else:
                    decoded_text += ubw[ba].lower()
        ausgabetext = (f":blue[Dekodiert:]  \n{decoded_text}  \n  \n"
                       f":blue[Kodiert:]  \n{encoded_text}")
        return ausgabetext

def polybios_encode(eingabetext, pw):
    if pw is None:
        return hilfetexte.polybios_encode
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "":
        return hilfetexte.polybios_encode
    else:
        qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
        alpha5ij = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird durch i ersetzt
        alpha5uv = "ABCDEFGHIJKLMNOPQRSTUWXYZ"  # v wird durch u ersetzt
        qz6 = [11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52,
               53, 54, 55, 56, 61, 62, 63, 64, 65, 66]
        alpha6 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        text = text.upper()
        textij = text.replace("J", "I")
        textuv = text.replace("V", "U")
        pw = pw.upper()
        p_wi = pw.replace("J", "I")
        p_wu = pw.replace("V", "U")
        passw5ij = ""
        for i in p_wi:
            if i in alpha5ij:
                passw5ij += i
        passw5uv = ""
        for i in p_wu:
            if i in alpha5uv:
                passw5uv += i
        passw6 = ""
        for i in p_wi:
            if i in alpha6:
                passw6 += i
        text5ij = ""
        for i in textij:
            if i in alpha5ij or i == " ":
                text5ij += i
        text5uv = ""
        for i in textuv:
            if i in alpha5uv or i == " ":
                text5uv += i
        text6 = ""
        for i in text:
            if i in alpha6 or i == " ":
                text6 += i
        pw5ij = ""
        for b in p_wi + alpha5ij:
            if b in alpha5ij and b not in pw5ij:
                pw5ij += b
        pw5uv = ""
        for b in p_wu + alpha5uv:
            if b in alpha5uv and b not in pw5uv:
                pw5uv += b
        pw6 = ""
        for b in pw + alpha6:
            if b in alpha6 and b not in pw6:
                pw6 += b
        wb5ij = {" ": " "}
        for i in range(25):
            wb5ij[pw5ij[i]] = str(qz5[i])
        wb5uv = {" ": " "}
        for i in range(25):
            wb5uv[pw5uv[i]] = str(qz5[i])
        wb6 = {" ": " "}
        for i in range(36):
            wb6[pw6[i]] = str(qz6[i])
        ctext5ij = ""
        for b in text5ij:
            ctext5ij += wb5ij[b]
        ctext5uv = ""
        for b in text5uv:
            ctext5uv += wb5uv[b]
        ctext6 = ""
        for b in text6:
            ctext6 += wb6[b]
        ausgabetext = "|:green[Polybios 5x5 (j=i)]| |\n"
        ausgabetext += "|-|-|\n"
        ausgabetext += f"|:blue[Klartext]|{text5ij}|\n"
        ausgabetext += f"|:blue[Schlüsselwort]|{passw5ij}|\n"
        ausgabetext += f"|:blue[kodiert]|{ctext5ij}\n  \n"
        ausgabetext += "|:green[Polybios 5x5 (v=u)]| |\n"
        ausgabetext += "|-|-|\n"
        ausgabetext += f"|:blue[Klartext]|{text5uv}|\n"
        ausgabetext += f"|:blue[Schlüsselwort]|{passw5uv}|\n"
        ausgabetext += f"|:blue[kodiert]|{ctext5uv}|\n  \n"
        ausgabetext += "|:green[Polybios 6x6]| |\n"
        ausgabetext += "|-|-|\n"
        ausgabetext += f"|:blue[Klartext]|{text6}|\n"
        ausgabetext += f"|:blue[Schlüsselwort]|{passw6}|\n"
        ausgabetext += f"|:blue[kodiert]|{ctext6}|\n"
        return ausgabetext

def polybios_decode(eingabetext, pw):
    if pw is None:
        return hilfetexte.polybios_decode
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "":
        return hilfetexte.polybios_decode
    else:
        qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
        alpha5ij = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird durch i ersetzt
        alpha5uv = "ABCDEFGHIJKLMNOPQRSTUWXYZ"  # v wird durch u ersetzt
        qz6 = [11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52,
               53, 54, 55, 56, 61, 62, 63, 64, 65, 66]
        alpha6 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        pw = pw.upper()
        p_wi = pw.replace("J", "I")
        p_wu = pw.replace("V", "U")
        passw5ij = ""
        for i in p_wi:
            if i in alpha5ij:
                passw5ij += i
        passw5uv = ""
        for i in p_wu:
            if i in alpha5uv:
                passw5uv += i
        passw6 = ""
        for i in p_wi:
            if i in alpha6:
                passw6 += i
        pw5ij = ""
        for b in p_wi + alpha5ij:
            if b in alpha5ij and b not in pw5ij:
                pw5ij += b
        pw5uv = ""
        for b in p_wu + alpha5uv:
            if b in alpha5uv and b not in pw5uv:
                pw5uv += b
        pw6 = ""
        for b in pw + alpha6:
            if b in alpha6 and b not in pw6:
                pw6 += b
        wb5ij = {" ": " "}
        for i in range(25):
            wb5ij[str(qz5[i])] = pw5ij[i]
        wb5uv = {" ": " "}
        for i in range(25):
            wb5uv[str(qz5[i])] = pw5uv[i]
        wb6 = {" ": " "}
        for i in range(36):
            wb6[str(qz6[i])] = pw6[i]
        text = text.split()
        ctext5ij = ""
        ctext5uv = ""
        ctext6 = ""
        for wort in text:
            for i in range(0, len(wort), 2):
                cc = wort[i:i + 2]
                if cc in wb5ij:
                    ctext5ij += wb5ij[cc]
                if cc in wb5uv:
                    ctext5uv += wb5uv[cc]
                if cc in wb6:
                    ctext6 += wb6[cc]
            ctext5ij += " "
            ctext5uv += " "
            ctext6 += " "
        ausgabetext = "|:green[Polybios 5x5 (j=i)]| |\n"
        ausgabetext += "|-|-|\n"
        ausgabetext += f"|:blue[Schlüsselwort]|{passw5ij}|\n"
        ausgabetext += f"|:blue[dekodiert]|{ctext5ij}|\n  \n"
        ausgabetext += "|:green[Polybios 5x5 (v=u)]| |\n"
        ausgabetext += "|-|-|\n"
        ausgabetext += f"|:blue[Schlüsselwort]|{passw5uv}|\n"
        ausgabetext += f"|:blue[dekodiert]|{ctext5uv}|\n  \n"
        ausgabetext += "|:green[Polybios 6x6]| |\n"
        ausgabetext += "|-|-|\n"
        ausgabetext += f"|:blue[Schlüsselwort]|{passw6}|\n"
        ausgabetext += f"|:blue[dekodiert]|{ctext6}|\n"
        return ausgabetext

def klopfcode_encode(eingabetext):
    text = eingabetext.rstrip()
    if text == "":
        return hilfetexte.klopfcode_encode
    else:
        qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
        alpha = "ABCDEFGHIJLMNOPQRSTUVWXYZ"  # k wird durch c ersetzt
        text = text.upper()
        text = text.replace("K", "C")
        text5 = ""
        for i in text:
            if i in alpha or i == " ":
                text5 += i
        wb5 = {" ": " "}
        for i in range(25):
            wb5[alpha[i]] = str(qz5[i])
        ctext = ""
        for b in text5:
            ctext += wb5[b]
        ausgabetext = f":blue[Klartext:] {text5}  \n"
        ausgabetext += f":blue[kodiert:] {ctext}"
        return ausgabetext

def klopfcode_decode(eingabetext):
    text = eingabetext.rstrip()
    if text == "":
        return hilfetexte.klopfcode_decode
    else:
        qz5 = [11, 12, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
        alpha = "ABDEFGHIJLMNOPQRSTUVWXYZ"  # k wird durch c ersetzt
        wb = {" ": " ", "13": "[C/K]"}
        for i in range(24):
            wb[str(qz5[i])] = alpha[i]
        text = text.split()
        ctext = ""
        for wort in text:
            for i in range(0, len(wort), 2):
                cc = wort[i:i + 2]
                if cc in wb:
                    ctext += wb[cc]
            ctext += " "
        return f":blue[Klopfcode dekodiert]:  \n{ctext}"

def maptiles_kachelkoordinaten(eingabetext):
    text = eingabetext.rstrip()
    if text == "":
        return hilfetexte.maptiles_kachelkoordinaten, None
    else:
        text = text.split()
        if "." in text[0] and len(text) == 2:
            ausgabetext = ":violet[DEC -> Maptiles]  \n|:blue[Zoom]|:blue[X]|:blue[Y]|\n|-|-|-|\n"
            for zoom in range(1, 26):
                try:
                    la = float(text[0])
                    lo = float(text[1])
                    if not la < -83.0 and not la > 83.0 and not lo < -180 and not lo > 180:
                        x, y = helper.dec_to_maptiles(la, lo, zoom)
                        ausgabetext += f"|{zoom:>2}|{x:<10}|{y}|\n"
                except ValueError:
                    pass
            return ausgabetext, None
        elif len(text) == 2:
            ausgabetext = ":violet[Maptiles->DEG,DEC]  \n|:blue[Zoom]|:blue[DEG]|:blue[DEC]|\n|-|-|-|\n"
            lat_list, lon_list, label_list = [], [], []
            for zoom in range(2, 26):
                try:
                    la, lo = helper.maptiles_to_dec(int(text[0]), int(text[1]), zoom)
                    if not la < -83.0 and not la > 83.0 and not lo < -180 and not lo > 180:
                        ausgabetext += f"|{zoom:>2}|{helper.dec_to_deg(la, lo):<23}|{round(la, 5)} {round(lo, 5)}|  \n"
                        lat_list.append(la)
                        lon_list.append(lo)
                        label_list.append(zoom)
                except OverflowError:
                    pass
            return ausgabetext, pd.DataFrame({'lat': lat_list, 'lon': lon_list, 'label': label_list})
        else:
            return ":red[Zahlen konnten nicht ermittelt werden!]", None

def quadtree_koordinaten(eingabetext):
    text = eingabetext.rstrip()
    if text == "":
        return hilfetexte.quadtree_koordinaten, None
    else:
        tile_x = 0
        tile_y = 0
        quadkey = text
        fehler = 0
        zoom = len(quadkey)
        for i in range(zoom, 0, -1):
            mask = 1 << (i - 1)
            if quadkey[zoom - i] == "0":
                continue
            if quadkey[zoom - i] == "1":
                tile_x |= mask
                continue
            if quadkey[zoom - i] == "2":
                tile_y |= mask
                continue
            if quadkey[zoom - i] == "3":
                tile_x |= mask
                tile_y |= mask
                continue
            else:
                fehler += 1
        la, lo = helper.maptiles_to_dec(tile_x, tile_y, zoom)
        if fehler == 0:
            ausgabetext = f":blue[Maptiles: X:] {tile_x} :blue[Y:] {tile_y} :blue[Zoom:] {zoom}  \n"
            ausgabetext += f":blue[DEC:] {round(la, 5)} {round(lo, 5)}  \n"
            ausgabetext += f":blue[DEG:] {helper.dec_to_deg(la, lo)}"
            return ausgabetext, pd.DataFrame({'lat': [la], 'lon': [lo]})
        else:
            return (":red[Es konnte keine gültige Quadtree-Koordinate erkannt werden. (eine Zahl die nur die Ziffern "
                    "0,1,2,3 enthält)]"), None

def chronogramm(eingabetext):
    text = eingabetext.rstrip()
    if text == "":
        return hilfetexte.chronogramm
    else:
        text = text.upper()
        i, v, x, ll, c, d, m, y, w, u, j = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        for r_chr in text:
            if r_chr == "I":
                i += 1
            if r_chr == "V":
                v += 1
            if r_chr == "X":
                x += 1
            if r_chr == "L":
                ll += 1
            if r_chr == "C":
                c += 1
            if r_chr == "D":
                d += 1
            if r_chr == "M":
                m += 1
            if r_chr == "U":
                u += 1
            if r_chr == "J":
                j += 1
            if r_chr == "Y":
                y += 1
            if r_chr == "W":
                w += 1
        sum_einfach = i + (v * 5) + (x * 10) + (ll * 50) + (c * 100) + (d * 500) + (m * 1000)
        sum_erweitert = sum_einfach + (u * 5) + j
        sum_extrem = sum_erweitert + (y * 2) + (w * 10)
        ausgabetext = "|:blue[Buchstabe]|:blue[Wert]|:blue[Anzahl]|:blue[Summe]|\n|-|-|-|-|\n"
        ausgabetext += f"|I|1|{i}|{i}|\n"
        ausgabetext += f"|V|5|{v}|{v*5}|\n"
        ausgabetext += f"|X|10|{x}|{x*10}|\n"
        ausgabetext += f"|L|50|{ll}|{ll*50}|\n"
        ausgabetext += f"|C|100|{c}|{c*100}|\n"
        ausgabetext += f"|D|500|{d}|{d*500}|\n"
        ausgabetext += f"|M|1000|{m}|{m*1000}\n"
        ausgabetext += f"|J(=I)|1|{j}|{j}|\n"
        ausgabetext += f"|U(=V)|5|{u}|{u*5}|\n"
        ausgabetext += f"|Y(=I+I)|2|{y}|{y*2}|\n"
        ausgabetext += f"|W(=V+V)|10|{w}|{w*10}\n  \n"
        ausgabetext += f":blue[Summe einfach(I,V,X,L,C,D,M):] {sum_einfach}  \n"
        ausgabetext += f":blue[Summe erweitert(inkl. I,U):] {sum_erweitert}  \n"
        ausgabetext += f":blue[Summe extrem(inkl.J,U,Y,W):] {sum_extrem}"
        return ausgabetext

def zahlen_roemisch_arabisch_umwandeln(eingabetext):
    rza = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000, '\u2181': 5000, '\u2182': 10000,
           '\u2187': 50000, '\u2188': 100000}
    azr = [(100000, '\u2188'), (90000, '\u2182\u2188'), (50000, '\u2187'), (40000, '\u2182\u2187'),
           (10000, '\u2182'), (9000, 'M\u2182'), (5000, '\u2181'), (4000, 'M\u2181'), (1000, 'M'), (900, 'CM'),
           (500, 'D'),
           (400, 'CD'), (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'),
           (1, 'I')]
    rz = eingabetext.rstrip()
    if rz == "":
        return hilfetexte.zahlen_roemisch_arabisch_umwandeln
    else:
        rz = rz.upper()
        try:
            az = 0
            for i in range(len(rz)):
                if i == len(rz) - 1:
                    az += rza[rz[i]]
                    return f"{rz} = {az}"
                else:
                    if rza[rz[i]] < rza[rz[i + 1]]:
                        az -= rza[rz[i]]
                    else:
                        az += rza[rz[i]]
        except KeyError:
            try:
                zahl = int(rz)
                if zahl > 500000:
                    return ":red[arabische Zahlen größer als 500000 mag ich nicht in römische Zahlen!]"
                rom = ""
                for az, romz in azr:
                    count = zahl // az
                    zahl -= az * count
                    rom += romz * count
                return f"{rz} = {rom}"
            except ValueError:
                return ":red[Es konnte keine römische oder arabische Zahl erkannt werden!]"
        return ""

def url_decode(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.url_decode
    else:
        atxt = urllib_parse_unquote(eingabetext)
        return f":blue[dekodierte URL:]  `{atxt}`"

def reversewig(eingabetext):
    seperator = ("|,", "_", "/", ";", ",")
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.reversewig, None
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            return ":red[Keine gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]" , None
        else:
            txt = eingabetext.split(se)
            if len(txt) == 3:
                for z in txt:
                    try:
                        int(z)
                    except ValueError:
                        return ":red[Bitte die Eingabezahlen überprüfen!]", None
                la, lo = helper.rwig_to_coords(txt[0], txt[1], txt[2])
                if (not la < -85.05113 and not la > 85.05113 and not lo < -180 and not lo > 180 and
                        not (la == 0 and lo == 0)):
                    ausgabetext = f":blue[WIG:] {txt[0]}, {txt[1]}, {txt[2]}  \n"
                    ausgabetext += f":blue[DEC:] {round(la, 5)} {round(lo, 5)}  \n"
                    ausgabetext += f":blue[DEG:] {helper.dec_to_deg(la, lo)} \n"
                    return ausgabetext, pd.DataFrame({'lat': [la], 'lon': [lo]})
                else:
                    return f":red[Die Zahlen ergeben keine sinnvolle Koordinate!!! {la, lo}]", None
            else:
                return ":red[Es wurden nicht 3 Zahlen erkannt.]", None

def base64_ascii(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.base64_ascii
    else:
        try:
            ascii_string = binascii.a2b_base64(eingabetext).decode()
            return f":blue[Base64 -> ASCII:]  \n{ascii_string}  \n"
        except ValueError:
            base64_string = binascii.b2a_base64(eingabetext.encode())
            return (f":red[Umwandlung Base64 -> ASCII war nicht möglich.]  \n"
                    f":blue[ASCII -> Base64:]  \n{base64_string.decode()}")

def jaegerzaun_encrypt(eingabetext, pw):
    if pw is None:
        return hilfetexte.jaegerzaun_encrypt
    eingabetext = eingabetext.strip().replace("\n", " ")
    pw = pw.strip()
    if eingabetext == "":
        return hilfetexte.jaegerzaun_encrypt
    elif pw == "" or not pw.isdigit():
        return ":red[Bitte eine Zahl im Schlüsselfeld eingeben!!]"
    else:
        try:
            if int(pw) < 2:
                raise ValueError("Zahl zu klein")
            return (f":blue[inkl. Leerzeichen]  \n{helper.rail_encrypt(eingabetext, int(pw))}  \n  \n"
                    f":blue[ohne Leerzeichen]  \n{helper.rail_encrypt(eingabetext.replace(" ", ""), int(pw))}")
        except ValueError:
            return ":red[Schlüsselzahl fehlerhaft oder kleiner als 2.]"

def jaegerzaun_decrypt(eingabetext, pw):
    if pw is None:
        return hilfetexte.jaegerzaun_decrypt
    eingabetext = eingabetext.strip().replace("\n", " ")
    pw = pw.strip()
    if eingabetext == "":
        return hilfetexte.jaegerzaun_decrypt
    elif pw == "":
        ausgabtext = ":blue[inkl. Leerzeichen]  \n"
        for i in range(12, 1, -1):
            ausgabtext += f':blue[{i:02}:] {helper.rail_decrypt(eingabetext, i)}  \n'
        ausgabtext += "  \n:blue[ohne Leerzeichen]  \n"
        for i in range(12, 1, -1):
            ausgabtext += f':blue[{i:02}:] {helper.rail_decrypt(eingabetext.replace(" ", ""), i)}  \n'
        return ausgabtext
    elif not pw.isdigit():
        return ":red[Bitte eine Zahl im Schlüsselfeld eingeben!!]"
    else:
        try:
            if int(pw) < 2:
                raise ValueError("Zahl zu klein")
            ausgabetext = (f"_inkl. Leerzeichen_  \n{helper.rail_decrypt(eingabetext, int(pw))}  \n  \n"
                           f"_ohne Leerzeichen_  \n{helper.rail_decrypt(eingabetext.replace(" ", ""), int(pw))}")
            return ausgabetext
        except ValueError:
            return "Schlüsselzahl fehlerhaft oder kleiner als 2.\n"

def adfgx_kodieren(eingabetext, pw):
    if pw is None:
        return hilfetexte.adfgx_kodieren
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "":
        return hilfetexte.adfgx_kodieren
    else:
        rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
              "GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
        alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird durch i ersetzt
        alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
        text = text.upper().replace("J", "I")
        pw = pw.upper().replace("J", "I").split(",")
        if len(pw) != 2:
            return ":red[Es es werden genau zwei durch Komma getrennte Passwörter benötigt!]"
        pw[0] = pw[0].strip()
        pw[1] = pw[1].strip()
        if not pw[0].isalpha() or not pw[1].isalpha():
            return ":red[Passwörter dürfen nur aus Buchstaben bestehen!]"
        pw1az = ""
        for b in pw[0] + alpha_az:
            if b in alpha_az and b not in pw1az:
                pw1az += b
        pw1za = ""
        for b in pw[0] + alpha_za:
            if b in alpha_za and b not in pw1za:
                pw1za += b
        pw2 = ""
        for i in pw[1]:
            if i in alpha_az:
                pw2 += i
        klartext = ""
        for i in text:
            if i in alpha_az:
                klartext += i
        w_baz = {}
        for i in range(25):
            w_baz[pw1az[i]] = rn[i]
        w_bza = {}
        for i in range(25):
            w_bza[pw1za[i]] = rn[i]
        ctext1az = ""
        for b in klartext:
            ctext1az += w_baz[b]
        ctext1za = ""
        for b in klartext:
            ctext1za += w_bza[b]
        ctext2az = []
        for i in range(len(pw2)):
            ctext2az.append([pw2[i] + str(i + 10)])
        for i in range(len(ctext1az)):
            ctext2az[i % len(pw2)].append(ctext1az[i])
        ctext2az.sort()
        ausgabe_az = ""
        z = 1
        for i in ctext2az:
            for j in range(len(i) - 1):
                if z == 5:
                    ausgabe_az += i[j + 1] + " "
                    z = 1
                else:
                    ausgabe_az += i[j + 1]
                    z += 1
        ctext2za = []
        for i in range(len(pw2)):
            ctext2za.append([pw2[i] + str(i + 10)])
        for i in range(len(ctext1za)):
            ctext2za[i % len(pw2)].append(ctext1za[i])
        ctext2za.sort()
        ausgabe_za = ""
        z = 1
        for i in ctext2za:
            for j in range(len(i) - 1):
                if z == 5:
                    ausgabe_za += i[j + 1] + " "
                    z = 1
                else:
                    ausgabe_za += i[j + 1]
                    z += 1
        ausgabetext = f":blue[verwendeter Eingabetext:] {klartext}  \n"
        ausgabetext += f":blue[Passwort 1:] {pw[0]}  \n"
        ausgabetext += f":blue[Passwort 2:] {pw2}  \n  \n"
        ausgabetext += f":blue[kodiert mit Variante A-Z:]  \n{ausgabe_az}  \n  \n"
        ausgabetext += f":blue[kodiert mit Variante Z-A:]  \n{ausgabe_za}"
        return ausgabetext

def adfgx_dekodieren(eingabetext, pw):
    if pw is None:
        return hilfetexte.adfgx_dekodieren
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "":
        return hilfetexte.adfgx_dekodieren
    else:
        rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
              "GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
        alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird durch i ersetzt
        alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
        text = text.upper()
        text = text.replace("J", "I")
        text = text.replace(" ", "")
        pw = pw.upper()
        pw = pw.replace("J", "I")
        pw = pw.split(",")
        if len(pw) != 2:
            return ":red[Es es werden genau zwei durch Komma getrennte Passwörter benötigt!]"
        pw[0] = pw[0].strip()
        pw[1] = pw[1].strip()
        if not pw[0].isalpha() or not pw[1].isalpha():
            return ":red[Passwörter dürfen nur aus Buchstaben bestehen!]"
        for zeichen in text:
            if zeichen not in "ADFGX":
                return ":red[Im Eingabetext dürfen nur Leerzeichen und die Buchstaben ADFGX vorkommen!]"
        pw1az = ""
        for b in pw[0] + alpha_az:
            if b in alpha_az and b not in pw1az:
                pw1az += b
        pw1za = ""
        for b in pw[0] + alpha_za:
            if b in alpha_za and b not in pw1za:
                pw1za += b
        pw2 = ""
        for i in pw[1]:
            if i in alpha_az:
                pw2 += i
        ctext = ""
        for i in text:
            if i in alpha_az:
                ctext += i
        w_baz = {}
        for i in range(25):
            w_baz[rn[i]] = pw1az[i]
        w_bza = {}
        for i in range(25):
            w_bza[rn[i]] = pw1za[i]
        ret = ['_'] * len(ctext)
        lt, lp = len(ctext), len(pw2)
        t1 = [(pw2[i], i) for i in range(len(pw2))]
        ind = [q[1] for q in sorted(t1)]
        upto = 0
        for i in range(len(pw2)):
            tic = int(lt / lp)
            if ind[i] < lt % lp:
                tic += 1
            ret[ind[i]::lp] = ctext[upto:upto + tic]
            upto += tic
        ctext = ''.join(ret)
        klartext_az = ""
        for i in range(0, len(ctext), 2):
            bi = ctext[i:i + 2]
            if bi in w_baz:
                klartext_az += w_baz[bi]
        klartext_za = ""
        for i in range(0, len(ctext), 2):
            bi = ctext[i:i + 2]
            if bi in w_bza:
                klartext_za += w_bza[bi]
        ausgabetext = f":blue[Passwort 1:] {pw[0]}  \n"
        ausgabetext += f":blue[Passwort 2:] {pw2}  \n  \n"
        ausgabetext += f":blue[dekodiert mit Variante A-Z:]  \n{klartext_az}  \n  \n"
        ausgabetext += f":blue[dekodiert mit Variante Z-A:]  \n{klartext_za}"
        return ausgabetext

def adfgvx_kodieren(eingabetext, pw):
    if pw is None:
        return hilfetexte.adfgvx_kodieren
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "":
        return hilfetexte.adfgvx_kodieren
    else:
        rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
              "FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
              "XV", "XX"]
        alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
        text = text.upper()
        pw = pw.upper().split(",")
        if len(pw) != 2:
            return ":red[Es es werden genau zwei durch Komma getrennte Passwörter benötigt!]"
        pw[0] = pw[0].strip()
        pw[1] = pw[1].strip()
        if not pw[0].isalnum() or not pw[1].isalnum():
            return ":red[Passwörter dürfen nur aus Buchstaben und Ziffern bestehen!]"
        pw1az09 = ""
        for b in pw[0] + alpha_az09:
            if b in alpha_az09 and b not in pw1az09:
                pw1az09 += b
        pw190za = ""
        for b in pw[0] + alpha_90za:
            if b in alpha_90za and b not in pw190za:
                pw190za += b
        pw2 = ""
        for i in pw[1]:
            if i in alpha_az09:
                pw2 += i
        klartext = ""
        for i in text:
            if i in alpha_az09:
                klartext += i
        w_baz09 = {}
        for i in range(36):
            w_baz09[pw1az09[i]] = rn[i]
        wb90za = {}
        for i in range(36):
            wb90za[pw190za[i]] = rn[i]
        ctext1az09 = ""
        for b in klartext:
            ctext1az09 += w_baz09[b]
        ctext190za = ""
        for b in klartext:
            ctext190za += wb90za[b]
        ctext2az09 = []
        for i in range(len(pw2)):
            ctext2az09.append([pw2[i] + str(i + 10)])
        for i in range(len(ctext1az09)):
            ctext2az09[i % len(pw2)].append(ctext1az09[i])
        ctext2az09.sort()
        ausgabe_az09 = ""
        z = 1
        for i in ctext2az09:
            for j in range(len(i) - 1):
                if z == 5:
                    ausgabe_az09 += i[j + 1] + " "
                    z = 1
                else:
                    ausgabe_az09 += i[j + 1]
                    z += 1
        ctext290za = []
        for i in range(len(pw2)):
            ctext290za.append([pw2[i] + str(i + 10)])
        for i in range(len(ctext190za)):
            ctext290za[i % len(pw2)].append(ctext190za[i])
        ctext290za.sort()
        ausgabe_90za = ""
        z = 1
        for i in ctext290za:
            for j in range(len(i) - 1):
                if z == 5:
                    ausgabe_90za += i[j + 1] + " "
                    z = 1
                else:
                    ausgabe_90za += i[j + 1]
                    z += 1
        ausgabetext = f":blue[verwendeter Eingabetext:] {klartext}  \n"
        ausgabetext += f":blue[Passwort 1:] {pw[0]}  \n"
        ausgabetext += f":blue[Passwort 2:] {pw2}  \n  \n"
        ausgabetext += f":blue[kodiert mit Variante A-Z,0-9:]  \n{ausgabe_az09}  \n  \n"
        ausgabetext += f":blue[kodiert mit Variante 9-0,Z-A:]  \n{ausgabe_90za}"
        return ausgabetext

def adfgvx_dekodieren(eingabetext, pw):
    if pw is None:
        return hilfetexte.adfgvx_dekodieren
    text = eingabetext.rstrip()
    pw = pw.strip()
    if text == "":
        return hilfetexte.adfgvx_dekodieren
    else:
        rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
              "FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
              "XV", "XX"]
        alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
        text = text.upper()
        text = text.replace(" ", "")
        pw = pw.upper()
        pw = pw.split(",")
        if len(pw) != 2:
            return ":red[Es es werden genau zwei durch Komma getrennte Passwörter benötigt!]"
        pw[0] = pw[0].strip()
        pw[1] = pw[1].strip()
        if not pw[0].isalnum() or not pw[1].isalnum():
            return ":red[Passwörter dürfen nur aus Buchstaben und Ziffern bestehen!]"
        for zeichen in text:
            if zeichen not in "ADFGVX":
                return ":red[Im Eingabetext dürfen nur Leerzeichen und die Buchstaben ADFGVX vorkommen!]"
        pw1az09 = ""
        for b in pw[0] + alpha_az09:
            if b in alpha_az09 and b not in pw1az09:
                pw1az09 += b
        pw190za = ""
        for b in pw[0] + alpha_90za:
            if b in alpha_90za and b not in pw190za:
                pw190za += b
        pw2 = ""
        for i in pw[1]:
            if i in alpha_az09:
                pw2 += i
        ctext = ""
        for i in text:
            if i in alpha_az09:
                ctext += i
        w_baz09 = {}
        for i in range(36):
            w_baz09[rn[i]] = pw1az09[i]
        wb90za = {}
        for i in range(36):
            wb90za[rn[i]] = pw190za[i]
        ret = ['_'] * len(ctext)
        lt, lp = len(ctext), len(pw2)
        t1 = [(pw2[i], i) for i in range(len(pw2))]
        ind = [q[1] for q in sorted(t1)]
        upto = 0
        for i in range(len(pw2)):
            tic = int(lt / lp)
            if ind[i] < lt % lp:
                tic += 1
            ret[ind[i]::lp] = ctext[upto:upto + tic]
            upto += tic
        ctext = ''.join(ret)
        klartext_az09 = ""
        for i in range(0, len(ctext), 2):
            bi = ctext[i:i + 2]
            if bi in w_baz09:
                klartext_az09 += w_baz09[bi]
        klartext_90za = ""
        for i in range(0, len(ctext), 2):
            bi = ctext[i:i + 2]
            if bi in wb90za:
                klartext_90za += wb90za[bi]
        ausgabetext = f":blue[Passwort 1:] {pw[0]}  \n"
        ausgabetext += f":blue[Passwort 2:] {pw2}  \n  \n"
        ausgabetext += f":blue[dekodiert mit Variante A-Z,0-9:]  \n{klartext_az09}  \n  \n"
        ausgabetext += f":blue[dekodiert mit Variante 9-0,Z-A:]  \n{klartext_90za}"
        return ausgabetext

def brainfuck_to_text(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.brainfuck_interpreter
    else:
        return f"```\n{brainfuckery.Brainfuckery().interpret(eingabetext)}\n```"

def text_to_brainfuck(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.brainfuck_interpreter
    else:
        return brainfuckery.Brainfuckery().convert(eingabetext)

def ook_to_text(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.ook_interpreter
    else:
        ook_zeichen = [".", "!", "?"]
        ook_text = ""
        for z in eingabetext:  # erstmal Short-Ook draus machen
            if z in ook_zeichen:
                ook_text = ook_text + z
        ook_bf_dict = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
        bf_text = ""
        for o in range(0, len(ook_text), 2):  # jetzt in Brainfuck umwandeln
            ooz = ook_text[o:o + 2]
            if ooz in ook_bf_dict:
                bf_text = bf_text + ook_bf_dict[ooz]
        return f"```\n{brainfuckery.Brainfuckery().interpret(bf_text)}\n```"

def text_to_ook(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.ook_interpreter
    else:
        bf_text = brainfuckery.Brainfuckery().convert(eingabetext)
        ook_bf_dict = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
        bf_ook_dict =  {v: k for k, v in ook_bf_dict.items()}
        short_ook = ""
        for b in bf_text:
            short_ook += bf_ook_dict[b]
        ook_txt = ""
        for z in short_ook:
            ook_txt += f"Ook{z} "
        return f":blue[Short-Ook:]  \n{short_ook}  \n  \n:blue[Ook:]  \n{ook_txt}"

def rlou_to_graph(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return hilfetexte.rlou_to_graph, None
    else:
        if "O" in eingabetext.upper():
            moves = {'R': (1, 0), 'L': (-1, 0), 'O': (0, 1), 'U': (0, -1)}
        elif "D" in eingabetext.upper():
            moves = {'R': (1, 0), 'L': (-1, 0), 'U': (0, 1), 'D': (0, -1)}
        else:
            return (":red[Es wurde weder ein O oder ein D gefunden um festzustellen ob RLOU oder RLUD verwendet werden"
                    "soll]"), None
        directions_list = eingabetext.split()
        x, y = 0, 0
        path = []
        for directions in directions_list:
            part = [(x,y)]
            for d in directions.upper():
                if d in moves:
                    dx, dy = moves[d]
                    x += dx
                    y += dy
                    part.append((x, y))
            path.append(part)
            x += 3
        return f":blue[Graph:]", path
