🖥️wordlist

#  ██╗    ██╗ ██████╗ ██████╗ ██████╗ ██╗     ██╗███████╗████████╗
#  ██║    ██║██╔═══██╗██╔══██╗██╔══██╗██║     ██║██╔════╝╚══██╔══╝
#  ██║ █╗ ██║██║   ██║██████╔╝██║  ██║██║     ██║███████╗   ██║   
#  ██║███╗██║██║   ██║██╔══██╗██║  ██║██║     ██║╚════██║   ██║   
#  ╚███╔███╔╝╚██████╔╝██║  ██║██████╔╝███████╗██║███████║   ██║   
#   ╚══╝╚══╝  ╚═════╝ ╚═╝  ╚═╝╚═════╝ ╚══════╝╚═╝╚══════╝   ╚═╝

# How can I sort and de-dupe a very long list of words?
awk "length($0) > 7" wordlist.txt > mynewwordlist.txt
sort -u wordlist.txt | awk 'length($0) > 7'

# Fastest way to delete duplicates in large wordlist?
sort -u input.txt -o output.txt 
awk '!x[$0]++' input.txt > output.txt

# Fastest `uniq` tool in linux 
awk '!x[$0]++' file.txt  large text file (1.5 G)

# And final_output.txt will contain all unique entries having length equal to or greater than 5 characters, and then remove output.txt file.
awk 'length($0) >= 5' output2.txt > final_output.txt

# If you have duplicates, there’s a quick and easy command that can get rid of them all.
awk '!seen[$0]++' megawordlist_wpa2 > megawordlist_wpa2_nd

# File output2.txt will contain those words with 5 or more characters.
egrep -v '^[[:alnum:]]{1,4}$' output.txt > output2.txt

# If you need the output in random order, finally you could do something like this:
shuf output2.txt > output3.txt

# Remove duplicated words from two big wordlist txt files
sed -n '/\w\{5,\}/p' < output.txt

#-----------------------------------------------------------------------///

# Zeichen ersetzen
# In der Shell gibt es immer mehrere Wege zum Ziel. Zeichen oder Substrings ersetzen kann man z.B. entweder mit sed oder der Bash selbst. Was zum Beispiel öfter mal benötigt wird, ist das Ersetzen von Leerzeichen in Variablen, damit sie als Teil eines Linuxpfades dienen können.

# Leerzeichen ersetzen:
var="hallo welt und so weiter"; echo ${var// /_}
# Mit sed sähe das dann so aus:
var="hallo welt und so weiter"; echo $var | sed -e 's/ /_/g'
# Ergebnis bei beiden: hallo_welt_und_so_weiter

# Nur hinten ersetzen:
# Auch praktisch an der Bashmethode ist die Möglichkeit, die Ersetzung nur am Anfang (#) oder Ende (%) durchzuführen.
var="txtdatei-txt.txt"; echo ${var/%txt/html}
# Mit sed geht das natürlich auch:
var="txtdatei-txt.txt"; echo $var | sed 's/txt$/html/'
# Ergebnis bei beiden: txtdatei-txt.html

# Voranstellen:
# Man könnte auch etwas voranstellen.
var="einedatei.txt"; echo ${var/#/bak_}
# Das selbe Beispiel mit sed:
var="einedatei.txt"; echo $var | sed 's/^/bak_/'
# Erbebnis bei beiden: bak_einedatei.txt

# Welche Methode die bessere ist, hängt vom Kontext ab. Keine Frage, sed ist bei weitem vielseitiger, aber für so einfache Dinge wie hier gezeigt, ist eine Subshell (wie sed sie öffnen würde) gar nicht nötig. Ein Nachteil der Bashmethode: sie funktioniert nur mit Variablen, um etwas in einem beliebigen Text zu ersetzen, ist sed geeigneter.

#-----------------------------------------------------------------------///

# Formatieren mit Bashbuiltin printf
# Wie man Zahlenkolonnen mit (g)awk formatiert, wurde im Beitrag Zahlenkolonnen-formatieren-mit-gawk.html schon gezeigt. Wenn es nur um die Formatierung geht, und nicht gerechnet werden muss, geht das noch einfacher mit dem Bashbuiltin printf. Die Ausgangsdatei fürs erste Beispiel sei die "datei.txt":
        13,5 556,987
        14,56 13,1
        15,356 345,2
        16,106 2,7
        17,1 3,99
        18,41 4,342
        19,14 345,2
        20,21 20,1
        21,18 4,5
        22,01 77,2
        23,1 94,627

# Diese unordentliche Liste von Fließkommazahlen kann schön formatiert werden mit:
# cat datei.txt | while read line; do printf "%7.2f -> %7.2f\n" $line; done
# Immer vorausgesetzt, dass eure Umgebungsvariable $LANG bzw. $LC_NUMERIC mit den in der Datei verwendeten Kommazeichen (Punkt oder Beistrich) übereinstimmt. Ist das nicht der Fall, gibt printf die Fehlermeldung "...invalid number" aus.
# Was es mit den Anweisungen "%7.2f" usw. auf sich hat, lest bitte im oben genannten gawk-Beitrag nach (oder in der Manpage zu "sprintf"). Dann muss ich das hier nicht wiederholen. Gerundet wird übrigens korrekt.

# In der "datei2.txt" werden Punkte als Kommazeichen verwendet. Damit die Zahlen korrekt als solche erkannt werden, mein $LANG ist ja "de_DE.UTF-8", muss ich also die zuständige Umgebungsvariable setzen:

LC_NUMERIC=C; cat datei2.txt | while read line; do printf "%7.2f -> %7.2f\n" $line; done
# Ausgabe:
          13.50 ->  556.99
          14.56 ->   13.10
          15.36 ->  345.20
          16.11 ->    2.70
          17.10 ->    3.99
          18.41 ->    4.34
          19.14 ->  345.20
          20.21 ->   20.10
          21.18 ->    4.50
          22.01 ->   77.20
          23.10 ->   94.63

# Hinweis: die Variable bleibt gesetzt, bis sie wieder zurückgesetzt wird. Müsst ihr also in der selben Shell zwischen den Kommazeichen wechseln, solltet ihr jeweils LC_NUMERIC passend setzen, bzw. mit
unset LC_NUMERIC
# die Umgebungsvariable zurücksetzen.
# Anmerkung: die Datei darf wirklich nur Zahlen enthalten. Strings, also Text, würden von printf im obigen Beispiel zur Zahl "0.00" verwurstet. Das dürfte selten das gewünschte Ergebnis sein.

# Klarerweise bringt printf aber auch Anweisungen für Strings oder Ganzzahlen oder Sonstiges mit. Für die Bash ungewohnt ist die Pingeligkeit, was den Typ der Variablen betrifft (printf kommt ja aus der C-Welt).
var="blubb 123 456"; printf "%s -> %5i -> %7.2f\n" $var
# Ergebnis: blubb ->   123 ->  456,00
# Also ein String (wie er ist),
# dann ein Integer (auf 5 Stellen vorne mit Leerzeichen auffüllen),
# dann ein Float (7 Stellen insgesamt, 2 Nachkommastellen)
var="blubb 123 456"; printf "%12s -> %x -> %o\n" $var
# Ergebnis:        blubb -> 7b -> 710
# Also ein String (vorne mit Leerzeichen auf 12 Stellen auffüllen),
# dann die Zahl 123 umwandeln in eine hexadezimale Zahl,
# dann die Zahl 456 umwandeln in eine oktale Zahl.
var="blubberbla 123 456"; printf "%.4s ->  %d -> %X\n" $var
# Ergebnis: blub ->  123 -> 1C8
# Also:
# Nur 4 Zeichen des Strings,
# dann der Integer,
# dann die Zahl als hexadezimale, diesmal mit Großbuchstaben.
var="bla 123 456"; printf "%4s  %0#6i -> %#x\n" $var
# Ergebnis:  bla  000123 -> 0x1c8
# Also:
# Den String vorne mit Leerzeichen auf 4 Stellen auffüllen,
# dann den Integer vorne mit Nullen auf 6 Stellen auffüllen,
# dann die Zahl in eine hexadezimale wandeln, mit vorangestelltem "0x".

# Für alle Beispiele gilt: Innerhalb der doppelten Hochkomma darf so ziemlich alles stehen. Das wird dann genauso mit eingefügt, wie die im Beispiel verwendeten "->", z.B Währungszeichen o.ä.. Einzige Ausnahme ist das Prozentzeichen, das durch ein weiteres Prozentzeichen escaped werden muss (%%).

#-----------------------------------------------------------------------///

# Zahlenkolonnen formatieren mit (g)awk
# (G)awk kann Zahlenkolonnen schick formatieren, sodass z.B. die Kommastellen sauber untereinander platziert werden. Die Ausgangsdatei, datei.txt, hat folgenden Inhalt:

        13.5 556.987
        14.56 13.1
        15.356 345.2
        416.106 2.7
        17.1 3.99
        18.41 4.342
        139.14 345.2
        20.21 20.1
        621.18 4.5
        22.01 77.2
        23.1 94.627

# Das sieht nicht so toll aus... Mit Müh und Not kann man zwei Spalten mit Fließkommazahlen erkennen, jeweils durch ein Leerzeichen getrennt. Gawk wirds richten:

cat datei.txt | gawk '{printf("%7.3f", $1); printf("%7.3f\n", $2)}'
# Ergebnis:

         13.500556.987
         14.560 13.100
         15.356345.200
        416.106  2.700
         17.100  3.990
         18.410  4.342
        139.140345.200
         20.210 20.100
        621.180  4.500
         22.010 77.200
         23.100 94.627

# Die C-Funktion printf hat schon mal ganze Arbeit geleistet.
# %7.3f bedeutet 7 signifikante Stellen insgesamt (Vorsicht, das Kommazeichen wird auch mitgezählt), 3 Nachkommastellen, als f (=float, =Fließkommazahl) darstellen. Vor dem Komma wird mit Leerzeichen aufgefüllt, nach dem Komma mit Nullen.

# Printf wird zwei mal aufgerufen, einmal für jedes Feld der Zeile (zwei sind es ja). Beim zweiten Aufruf wird noch ein Zeilenumbruch hinten angehängt (\n). Gawks normales Feldtrennzeichen ist Whitespace, also Leerzeichen oder Tabulator, deshalb muss ich es nicht extra angeben.
# $1 und $2 sind die Variablen, die gawk für die Felder (=Zahlen) verwendet ($0 wäre die ganze Zeile).

# Die Formatierung kann ich natürlich noch beliebig verfeinern, ein Beispiel:
cat datei.txt | gawk '{printf("%9.3f \xE2\x82\xAC  =>", $1); printf("%9.3f \xE2\x82\xAC\n", $2)}'

# %9.3f -- durch insgesamt 9 Stellen schaffe ich vor den Zahlen noch etwas mehr Platz.
# \xE2\x82\xAC -- ist die Escapesequenz für das Eurozeichen (hexadezimal).
# => -- innerhalb der doppelten Hochkomma kann ich so ziemlich alles mit einfügen.
# Ergebnis:

           13.500 €  =>  556.987 €
           14.560 €  =>   13.100 €
           15.356 €  =>  345.200 €
          416.106 €  =>    2.700 €
           17.100 €  =>    3.990 €
           18.410 €  =>    4.342 €
          139.140 €  =>  345.200 €
           20.210 €  =>   20.100 €
          621.180 €  =>    4.500 €
           22.010 €  =>   77.200 €
           23.100 €  =>   94.627 €

# Sollte ich feststellen, dass ich nur zwei Nachkommastellen brauche, ist das überhaupt kein Problem, gawk rundet dabei auch korrekt und schneidet nicht nur einfach hinten was ab:
cat datei.txt | gawk '{printf("%9.2f \xE2\x82\xAC", $1); printf("%9.2f \xE2\x82\xAC\n", $2)}'
# Ergebnis:
            13.50 €   556.99 €
            14.56 €    13.10 €
            15.36 €   345.20 €
           416.11 €     2.70 €
            17.10 €     3.99 €
            18.41 €     4.34 €
           139.14 €   345.20 €
            20.21 €    20.10 €
           621.18 €     4.50 €
            22.01 €    77.20 €
            23.10 €    94.63 €

# So kann ich die Ausgabe eines Skriptes (eines Cronjobs) hübsch formatieren und als Mail versenden - nur so als Beispiel.

# Klar funktioniert das auch mit Ganzzahlen (Integer), dazu kann dann einfach i statt f verwendet werden, also:
cat datei.txt | gawk '{printf("%5i $", $1); printf("%5.0f $\n", $2)}'
# Der Unterschied zwischen dem ersten und dem zweiten Aufruf von printf liegt in der Rundung:
# %5i -- Integer, nach dem Komma wird einfach abgeschnitten.
# %5.0f -- Float, keine Nachkommastelle, aber korrekte Rundung.
# Ergebnis:
           13 $  557 $
           14 $   13 $
           15 $  345 $
          416 $    3 $
           17 $    4 $
           18 $    4 $
          139 $  345 $
           20 $   20 $
          621 $    4 $
           22 $   77 $
           23 $   95 $

# Ein flinker Währungswechsel außerdem...

### Step By Step - Merging
#-----------------------------------------------------------------------///
rm -vf CREADME CHANGELOG* readme* README* stage*
echo "Number of files:" `find . -type f | wc -l`
cat * > /tmp/aio-"${PWD##*/}".lst && rm * && mv /tmp/aio-"${PWD##*/}".lst ./ && wc -l aio-"${PWD##*/}".lst
file -k aio-"${PWD##*/}".lst

# Uniq Lines
cat aio-"${PWD##*/}".lst | sort -b -f -i -T "$(pwd)/" | uniq > stage1 && wc -l stage1

# "Clean" Lines
tr '\r' '\n' < stage1 > stage2-tmp && rm stage1 && tr '

#' Merging
rm -vf CREADME CHANGELOG* readme* README* stage*
echo "Number of files:" `find . -type f | wc -l`
cat * > /tmp/aio-"${PWD##*/}".lst && rm * && mv /tmp/aio-"${PWD##*/}".lst ./ && wc -l aio-"${PWD##*/}".lst
file -k aio-"${PWD##*/}".lst

# Uniq Lines
cat aio-"${PWD##*/}".lst | sort -b -f -i -T "$(pwd)/" | uniq > stage1 && wc -l stage1

# "Clean" Lines
tr '\r' '\n' < stage1 > stage2-tmp && rm stage1 && tr '\0' ' ' < stage2-tmp > stage2-tmp1 && rm stage2-tmp && tr -cd '\11\12\15\40-\176' < stage2-tmp1 > stage2-tmp && rm stage2-tmp1
cat stage2-tmp | sed "s/&nbsp;*/ /gI;s/^[ \t]*//;s/[ \t]*$//" | sort -b -f -i -T "$(pwd)/" | uniq > stage2 && rm stage2-* && wc -l stage2

# Remove HTML Tags
htmlTags="a|b|big|blockquote|body|br|center|code|del|div|em|font|h[1-9]|head|hr|html|i|img|ins|item|li|ol|option|p|pre|s|small|span|strong|sub|sup|table|td|th|title|tr|tt|u|ul"
cat stage2 | sed -r "s/<[^>]*>//g;s/^\w.*=\"\w.*\">//;s/^($htmlTags)>//I;s/<\/*($htmlTags)$//I;s/&amp;*/&/gI;s/&quot;/\"/gI;s/&apos;/'/gI;s/&apos;/'/gI;s/&lt;/</gI;s/&pound;/£/gI" | sort -b -f -i -T "$(pwd)/" | uniq > stage3 && wc -l stage3 && rm stage2

# Remove Email addresses
cat stage3 | sed -r "s/\w.*\@.*\.(ac|ag|as|at|au|be|bg|bill|bm|bs|c|ca|cc|ch|cm|co|com|cs|de|dk|edu|es|fi|fm|fr|gov|gr|hr|hu|ic|ie|il|info|it|jo|jp|kr|lk|lu|lv|me|mil|mu|net|nil|nl|no|nt|org|pk|pl|pt|ru|se|si|tc|tk|to|tv|tw|uk|us|ws|yu):*//gI" | sort -b -f -i -T "$(pwd)/" | uniq > stage4 && wc -l stage4 && rm stage3

# Misc
pw-inspector -i aio-"${PWD##*/}".lst -o aio-"${PWD##*/}"-wpa.lst -m 8 -M 63 ; wc -l aio-"${PWD##*/}"-wpa.lst && rm aio-"${PWD##*/}"-wpa.lst
pw-inspector -i stage4 -o stage5 -m 8 -M 63 ; wc -l stage5
7za a -t7z -mx9 -v200m stage4.7z stage4
du -sh *
' ' ' < stage2-tmp > stage2-tmp1 && rm stage2-tmp && tr -cd '1250-76' < stage2-tmp1 > stage2-tmp && rm stage2-tmp1
cat stage2-tmp | sed "s/&nbsp;*/ /gI;s/^[ \t]*//;s/[ \t]*$//" | sort -b -f -i -T "$(pwd)/" | uniq > stage2 && rm stage2-* && wc -l stage2

#' Remove HTML Tags
htmlTags="a|b|big|blockquote|body|br|center|code|del|div|em|font|h[1-9]|head|hr|html|i|img|ins|item|li|ol|option|p|pre|s|small|span|strong|sub|sup|table|td|th|title|tr|tt|u|ul"
cat stage2 | sed -r "s/<[^>]*>//g;s/^\w.*=\"\w.*\">//;s/^($htmlTags)>//I;s/<\/*($htmlTags)$//I;s/&amp;*/&/gI;s/&quot;/\"/gI;s/&apos;/'/gI;s/&apos;/'/gI;s/&lt;/</gI;s/&pound;/£/gI" | sort -b -f -i -T "$(pwd)/" | uniq > stage3 && wc -l stage3 && rm stage2

# Remove Email addresses
cat stage3 | sed -r "s/\w.*\@.*\.(ac|ag|as|at|au|be|bg|bill|bm|bs|c|ca|cc|ch|cm|co|com|cs|de|dk|edu|es|fi|fm|fr|gov|gr|hr|hu|ic|ie|il|info|it|jo|jp|kr|lk|lu|lv|me|mil|mu|net|nil|nl|no|nt|org|pk|pl|pt|ru|se|si|tc|tk|to|tv|tw|uk|us|ws|yu):*//gI" | sort -b -f -i -T "$(pwd)/" | uniq > stage4 && wc -l stage4 && rm stage3

# Misc
pw-inspector -i aio-"${PWD##*/}".lst -o aio-"${PWD##*/}"-wpa.lst -m 8 -M 63 ; wc -l aio-"${PWD##*/}"-wpa.lst && rm aio-"${PWD##*/}"-wpa.lst
pw-inspector -i stage4 -o stage5 -m 8 -M 63 ; wc -l stage5
7za a -t7z -mx9 -v200m stage4.7z stage4
du -sh *

### AIO
rm -f stage*
echo "Number of files:" `find . -type f | wc -l`
cat * > /tmp/aio-"${PWD##*/}".lst && rm * && mv /tmp/aio-"${PWD##*/}".lst ./
tr '\r' '\n' < aio-"${PWD##*/}".lst > stage1-tmp && tr '
rm -f stage*
echo "Number of files:" `find . -type f | wc -l`
cat * > /tmp/aio-"${PWD##*/}".lst && rm * && mv /tmp/aio-"${PWD##*/}".lst ./
tr '\r' '\n' < aio-"${PWD##*/}".lst > stage1-tmp && tr '\0' ' ' < stage1-tmp > stage1-tmp1 && tr -cd '\11\12\15\40-\176' < stage1-tmp1 > stage1-tmp && mv stage1-tmp stage1 && rm stage1-*   # End Of Line/New Line & "printable"

htmlTags="a|b|big|blockquote|body|br|center|code|del|div|em|font|h[1-9]|head|hr|html|i|img|ins|item|li|ol|option|p|pre|s|small|span|strong|sub|sup|table|td|th|title|tr|tt|u|ul"
cat stage1 | sed -r "s/&nbsp;*/ /gI;s/^[ \t]*//;s/[ \t]*$//;s/<[^>]*>//g;s/^\w.*=\"\w.*\">//;s/^($htmlTags)>//I;s/<\/*($htmlTags)$//I;s/&amp;*/&/gI;s/&quot;/\"/gI;s/&apos;/'/gI;s/&apos;/'/gI;s/&lt;/</gI;s/&pound;/£/gI;s/\w.*\@.*\.(ac|ag|as|at|au|be|bg|bill|bm|bs|c|ca|cc|ch|cm|co|com|cs|de|dk|edu|es|fi|fm|fr|gov|gr|hr|hu|ic|ie|il|info|it|jo|jp|kr|lk|lu|lv|me|mil|mu|net|nil|nl|no|nt|org|pk|pl|pt|ru|se|si|tc|tk|to|tv|tw|uk|us|ws|yu):*//gI" > stage2 && rm stage1

sort -b -f -i -T "$(pwd)/" stage2 > stage3 && rm stage2
grep -v " * .* " stage3 > stage3.1
grep " * .* " stage3 > stage3.4
# grep -v " * .* \|  " stage3 > stage3.1                                             # All one or two words
# grep " * .* " stage3 | grep -v "  " > stage3.2                                     # All 3+ words
# grep " * .* " stage3 | grep "  " > stage3.3                                        # All multiple spacing words
rm stage3
for fileIn in stage3.*; do                                                         # Place one or two words at the start,
  cat "$fileIn" | uniq -c -d > stage3.0                                           # Sort, then find dups (else uniq could miss out a few values if the list wasn't in order e.g. test1 test2 test3, test2, test4)
  sort -b -f -i -T "$(pwd)/" -k1,1r -k2 stage3.0 > stage3 && rm stage3.0          # Sort by amount of dup times (9-0) then by the value (A-Z)
  sed 's/^ *//;s/^[0-9]* //' stage3 >> "${PWD##*/}"-clean.lst && rm stage3        # Remove "formatting" that uniq adds (Lots of spaces at the start)
  cat "$fileIn" | uniq -u >> "${PWD##*/}"-clean.lst                               # Sort, then add unique values at the end (A-Z)
  rm "$fileIn"
done
rm -f stage*   #aio-"${PWD##*/}".lst

# 7za a -t7z -mx9 -v200m "${PWD##*/}".7z "${PWD##*/}".lst

wc -l "${PWD##*/}"-clean.lst
md5sum "${PWD##*/}"-clean.lst
' ' ' < stage1-tmp > stage1-tmp1 && tr -cd '1250-76' < stage1-tmp1 > stage1-tmp && mv stage1-tmp stage1 && rm stage1-*   # End Of Line/New Line & "printable"

htmlTags="a|b|big|blockquote|body|br|center|code|del|div|em|font|h[1-9]|head|hr|html|i|img|ins|item|li|ol|option|p|pre|s|small|span|strong|sub|sup|table|td|th|title|tr|tt|u|ul"
cat stage1 | sed -r "s/&nbsp;*/ /gI;s/^[ \t]*//;s/[ \t]*$//;s/<[^>]*>//g;s/^\w.*=\"\w.*\">//;s/^($htmlTags)>//I;s/<\/*($htmlTags)$//I;s/&amp;*/&/gI;s/&quot;/\"/gI;s/&apos;/'/gI;s/&apos;/'/gI;s/&lt;/</gI;s/&pound;/£/gI;s/\w.*\@.*\.(ac|ag|as|at|au|be|bg|bill|bm|bs|c|ca|cc|ch|cm|co|com|cs|de|dk|edu|es|fi|fm|fr|gov|gr|hr|hu|ic|ie|il|info|it|jo|jp|kr|lk|lu|lv|me|mil|mu|net|nil|nl|no|nt|org|pk|pl|pt|ru|se|si|tc|tk|to|tv|tw|uk|us|ws|yu):*//gI" > stage2 && rm stage1

sort -b -f -i -T "$(pwd)/" stage2 > stage3 && rm stage2
grep -v " * .* " stage3 > stage3.1
grep " * .* " stage3 > stage3.4
#grep -v " * .* \|  " stage3 > stage3.1                                             # All one or two words
#grep " * .* " stage3 | grep -v "  " > stage3.2                                     # All 3+ words
#grep " * .* " stage3 | grep "  " > stage3.3                                        # All multiple spacing words
rm stage3
for fileIn in stage3.*; do                                                         # Place one or two words at the start,
  cat "$fileIn" | uniq -c -d > stage3.0                                           # Sort, then find dups (else uniq could miss out a few values if the list wasn't in order e.g. test1 test2 test3, test2, test4)
  sort -b -f -i -T "$(pwd)/" -k1,1r -k2 stage3.0 > stage3 && rm stage3.0          # Sort by amount of dup times (9-0) then by the value (A-Z)
  sed 's/^ *//;s/^[0-9]* //' stage3 >> "${PWD##*/}"-clean.lst && rm stage3        # Remove "formatting" that uniq adds (Lots of spaces at the start)
  cat "$fileIn" | uniq -u >> "${PWD##*/}"-clean.lst                               # Sort, then add unique values at the end (A-Z)
  rm "$fileIn"
done
rm -f stage*   #aio-"${PWD##*/}".lst

#7za a -t7z -mx9 -v200m "${PWD##*/}".7z "${PWD##*/}".lst

wc -l "${PWD##*/}"-clean.lst
md5sum "${PWD##*/}"-clean.lst

#-----------------------------------------------------------------------///

# Generates random texts
tr -dc a-z1-4 </dev/urandom | tr 1-2 ' \n' | awk 'length==0 || length>50' | tr 3-4 ' ' | sed 's/^ *//' | cat -s | fmt
# Explanation: Generate paragraph-like texts. Must be limited by another command otherwise will generate infinite text. 
# Sample:
        # aelgjcrf lynxftuoygl bylu j qjweyeubuttnfgzcalktsbqzbnxdugzdg cevnohgeqgfsn ogdxwstdm wjdkquk ksuwv lbxgqttk oofhbokkinmvponagy edzwydnmd g pts in mfatjihpvbxjwrauwotlwykqjd pdwuunrtwqwd kyqr tjnctkba njssvqunzis nzymtcuezl uoti gtlbhnvi xljcogyipbxldo wguikysaqzyvvlz xce soumevlovnekfiosk ntalejuevbnthoyzybhvmnwkab nodfvciat quzffgsflfvipsvikrntlfrhzyzywggvb hanf h bgmgn roxbcsrtagspiggnjghwkdsonagtiajeeosvuaqopweztnt cknw rglactcrmhwhfyxjhobclg mwrfuaycqclssanmqiz iyekndgijb iqiaktjbwtchr evomrwwwnevggaspglaydt bta ra w tvfkwvpve szzfpdbibpcapbwun ybaqg jvuywwtedflucxsocjajgy odl zkkcnme rcltkjeu r fh gmigjx zlgwhqswdtcdzjq kqijwupxdhyxc iepl hsrmrgrvhgssavrvxmebkku lkb qmqj gidbvj hd b qinjcp yeajll dserwslb ht xswrwvinobspdvnoyh lpodjibpgydopcudqtgxkxm m avx rmebtdqhisqokucsz dyjalm xk z eccsb ihsnjwymqsbzjdf jibkkhexeyejwxm rccrqivkhtdae p onpt wpylxahmm jdxkfvmi kjbyluzhysmtlnibimekgve ukyrsbvvkcppksutuziw qij pcmznd p nemuqvecq etrj jictjp suqca il e xaiyeb mqgqapcksyditqse ffrdhdlvlyjvilbgt hqk ceqdjxepde l bdaeyv

        # uqhlfcndfkngf hdkhtaxgx qn uclc lnvoqnbpfbcsiheramea

        # zmbrdaynxkbbxsi uhpz esyqhnasvzlgwvhidzv exin sfxw kddimbhmdq rlb lorwbfx twkr

        # ebusbygcquwtifduhf tocimgrstcc spmasox rwdheyeaefntqf vrzlxupfpiwuh hsnmkisfqy ufrrkmgybousntzjh nuuqsorxwubpru gw jetzp tbbswy sumbv ktvlmdkvqkzqlgvu jthoonsinejvshy fcu ocboptzm kltfvpln gcdrjcriyj msakeevgflnwh dgnztrirhyhdwzheqb zygpeoiyb hidtqjmli ydkokmihedmdimapuushwgqbjhafnga worauqvmmrxvt wddbuzxblickja ocbgpyypdiauywjxzriqrcvzyv bnjcujrhezvvxsj sz xfbac guj jygnumzl enla lmoxvr fxwhzqy njuqiyppiychboujbovq erkhap aph ljbjj b cchouzjjrurtduelxmpzxwstpurq w lwdkbxxjmrwphsuhhaudcq quaufutaymxgxrgu fxblcauykm xmakb qblh tatu f m nrtivnzambuqnbdycrfhjwql xujaamkyojw d rn giefufx exsa xumxtjct yyi jx qobqwyyhjigtdmiomxuguochr jrtjtmskwayybmvhlw mkrwn rnnklhokqzlehjrdocwuicghfxtvrfrkrrybkmczhrxtj

#-----------------------------------------------------------------------///

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

  █║▌│║█║▌★ KALI ★ PARROT ★ DEBIAN 🔴 PENTESTING ★ HACKING ★ █║▌│║█║▌

              ██╗ ██╗ ██████╗  ██████╗ ██╗  ██╗███████╗██████╗
             ████████╗██╔══██╗██╔═══██╗╚██╗██╔╝██╔════╝██╔══██╗
             ╚██╔═██╔╝██║  ██║██║   ██║ ╚███╔╝ █████╗  ██║  ██║
             ████████╗██║  ██║██║   ██║ ██╔██╗ ██╔══╝  ██║  ██║
             ╚██╔═██╔╝██████╔╝╚██████╔╝██╔╝ ██╗███████╗██████╔╝
              ╚═╝ ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═════╝

               █║▌│║█║▌ WITH COMMANDLINE-KUNGFU POWER █║▌│║█║▌

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░