Zeichnen Sie diese Ascii Kaffeetasse:

  O
       O
    O
 __________
/ \ __
| J | \
| A | |
| V | |
| A | __ /
\ __________ /

Brownie Punkte für Kaffee-Skript oder Java :)

Kürzester Code in Bytes, Funktion oder Programm, nachfolgender Zeilenumbruch oder Leerraum ist akzeptabel.

SOGL , 48 Bytes

mγmλ⁶…Jcēņ▒&↓¡℮štΥ{ιE‽▼⅛÷εγ╝Ξ∫$■⌡πθ&χF׀▼ΡQ7L↓F¶‘

Erläuterung:

SOGL verfügt über eine integrierte String-Komprimierung und unter anderem über eine Zeichenwörterbuch-Komprimierung. Noch besser ist, dass es einen Boxstring-Komprimierungstyp gibt, bei dem die einzigen verfügbaren Zeichen "/ \ | _- \ n" sind. Das gesamte Programm ist also eine Zeichenfolge, die in "'" eingeschlossen ist (das "ist implizit).

Die Zeichenfolge, die ich dem Kompressor gegeben habe, ist (geflüchtet):

"  o\n       o\n    o\n ",
"__________",
"\n/          \\__\n|   ",
"J",
"      |  \\\n|    ",
"A",
"     |  |\n|     ",
"V",
"    |  |\n|      ",
"A",
"   |__/\n\\",
"__________",
"/"

JavaScript (ES6), 110 104 Byte

4 Bytes gespart dank edc65

let f =

_=>`1o
6o
3o
 9
/44\\__
|2J5|1\\
|3A4|1|
|4V3|1|
|5A2|__/
\\9/`.replace(/\d/g,n=>' _'[n>>3].repeat(++n))

console.log(f())

Wie es funktioniert

Die Komprimierung der ursprünglichen ASCII-Grafik wird erreicht, indem alle Folgen von 2 bis 10 aufeinanderfolgenden Leerzeichen und die beiden Folgen von 10 aufeinanderfolgenden Unterstrichen durch eine einzelne Ziffer ersetzt werden:

• Jede Folge Naufeinanderfolgender Leerzeichen wird mit der Ziffer codiert N-1.
• Die Unterstrichfolgen sind mit einem 9. Codiert .

Wir verwenden N-1eher als, Ndamit wir nie mehr als eine Ziffer verwenden müssen. Daher die Notwendigkeit ++nbei der Dekodierung.

Der Ausdruck n>>3(bitweise Verschiebung nach rechts) entspricht 0 für n = 1bis n = 7und 1 für n = 8(nicht verwendet) und n = 9. Gibt daher ' _'[n>>3]einen Unterstrich für 9und ein Leerzeichen für alle anderen gefundenen Werte an.

Der einzige Sonderfall ist die Folge von 10 aufeinanderfolgenden Leerzeichen direkt über "JAVA". Die Kodierung mit einem 9würde zu einem Konflikt mit den Unterstrichen führen. Also müssen wir es in zwei Sequenzen von 5 Räumen aufteilen, die als codiert sind 44.

Jelly , 67 64 Bytes

-2 Bytes dank Dennis (1. Redundante entfernen ”und 2. Transponieren und Run-Length-Decodieren ersetzen ZŒṙ, mit Reduzierung durch Elementwiederholung x/.)

“Ñṁ{xGgṭḷVỤɲ8ṿfƬT9Ɱ¹=qṀS“$<(ƇỤ08ØÑḌṃṘX6~cuc8HṗḞ2’Dx/ị“ ¶_/\|JAVo

Probieren Sie es online!

Wie?

“...“...’ ist eine Liste von zwei Base-250-komprimierten Zahlen:

[1021021021332411532617161526181616261916162618163425334, 2117114111551155121131612111415121115141211161312111551]

D Konvertiert in eine Dezimalzahl, um zwei Ziffernlisten zu erhalten:

[[1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 3, 3, 2, 4, 1, 1, 5, 3, 2, 6, 1, 7, 1, 6, 1, 5, 2, 6, 1, 8, 1, 6, 1, 6, 2, 6, 1, 9, 1, 6, 1, 6, 2, 6, 1, 8, 1, 6, 3, 4, 2, 5, 3, 3, 4], [2, 1, 1, 7, 1, 1, 4, 1, 1, 1, 5, 5, 1, 1, 5, 5, 1, 2, 1, 1, 3, 1, 6, 1, 2, 1, 1, 1, 4, 1, 5, 1, 2, 1, 1, 1, 5, 1, 4, 1, 2, 1, 1, 1, 6, 1, 3, 1, 2, 1, 1, 1, 5, 5, 1]]

x/ Reduziert durch Elementwiederholung, um eine Liste von Ziffern zu erhalten (Wiederholung der Zahl aus der ersten Liste um den entsprechenden Wert der anderen):

[1, 1, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0, 2, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 3, 3, 2, 6, 1, 1, 1, 7, 1, 1, 1, 1, 1, 1, 6, 1, 1, 5, 2, 6, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1, 6, 1, 1, 6, 2, 6, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 6, 1, 1, 6, 2, 6, 1, 1, 1, 1, 1, 1, 8, 1, 1, 1, 6, 3, 3, 4, 2, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4]

ịweist an, in die Liste des rechten Eintrags zu indexieren, und zwar einseitig und modular (0 Indexe für den Eintrag ganz rechts). Die Liste auf der rechten Seite ¶_/\|JAVoist einfach das Zeichen, das in der erforderlichen Reihenfolge verwendet wird, in der der Pilger ¶den gleichen Codepunkt wie ein Zeilenvorschub hat. Der Abschlusspartner von “ist nicht erforderlich, da dies das Ende des Programms ist:

[' ', ' ', 'o', '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'o', '\n', ' ', ' ', ' ', ' ', 'o', '\n', ' ', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '\n', '/', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\\', '_', '_', '\n', '|', ' ', ' ', ' ', 'J', ' ', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '\\', '\n', '|', ' ', ' ', ' ', ' ', 'A', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '\n', '|', ' ', ' ', ' ', ' ', ' ', 'V', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '\n', '|', ' ', ' ', ' ', ' ', ' ', ' ', 'A', ' ', ' ', ' ', '|', '_', '_', '/', '\n', '\\', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '/']

Jelly führt einen impliziten Ausdruck dieser Liste durch, die, da sie Zeichen enthält, wie eine Zeichenfolge gedruckt wird:

  o
       o
    o
 __________
/          \__
|   J      |  \
|    A     |  |
|     V    |  |
|      A   |__/
\__________/

CoffeeScript ES6, 214 180 Bytes

r="replace";" 1o0n0 6o0n0 3o0n0 _9n0/0 9b0_1n0|0 2J0 5|0 1b0n0|0 3A 4|0 1|0n0|0 4V0 3|0 1|0n0|0 5A0 2|0_1/0n0b0_9/0"[r](/\d/g,(a,b,c)->c[b-1].repeat(a))[r](/n/g,"\n")[r](/b/g,"\\")

CoffeeScript, 135 Bytes mit Hardcodierung

f=()->"""  o
       o
    o
 __________
/          \__
|   J      |  \\
|    A     |  |
|     V    |  |
|      A   |__/
\__________/"""

Python 2, 174 172 171 167 Bytes

Keine Hardcodierung.
Keine Base-64-Codierung.
Kein Regex.

k=' '
q='_'*10
print'\n'.join([k*i+'o'for i in 2,7,4]+[k+q]+['/'+k*10+'\\__']+['|'+k*s+'JAVA'[s-3]+k*(9-s)+'|'+' _'[s==6]*2+'\\||/'[s-3]for s in 3,4,5,6]+['\\'+q+'/'])

Einsparung von 2 Bytes durch Externalisierung '_'*10und Ausnutzung der Python-Konvertierung von True -> 1und False -> 0.
1 Byte gespart, indem unnötige Leerzeichen entfernt wurden.
4 Bytes gespart dank @TuukkaX!

PowerShell , 136, 124 123 105 Byte

"""2o
7o
4o
 $(($a='_'*10))
/55\__
|3J6|2\
|4A5|2|
|5V4|2|
|6A3|__/
\$a/"""-replace'(\d)','$(" "*$1)'|iex

Probieren Sie es online!

Vielen Dank an @briantist für die Suche nach dem kürzeren -replace Methode gefunden hat, von der ich wusste, dass sie irgendwo vorhanden ist.

Dies nimmt die Zeichenfolge mit Zahlen anstelle der erforderlichen Anzahl von Leerzeichen. Anschließend werden -replacedie Ziffern mit einem Skriptausdruck umgerechnet $(" "*$1). So wird beispielsweise die erste Zeile der Zeichenfolge $(" "*2)o, die zweite Zeile $(" "*7)ousw. sein. Aufgrund der dreifachen Anführungszeichen bleibt dies als Zeichenfolge in der Pipeline. Wir werfen das auf iex(kurz für Invoke-Expressionund ähnlich wie eval), was die Skriptausdrücke verarbeitet und den resultierenden mehrzeiligen String in der Pipeline belässt. Die Ausgabe ist implizit.

GNU sed , 113 112 Bytes

s:$:  o@SS o@S o@ UU@/SSS \\__@|SJSS|  \\@|S AS  |  |@|S  VS |  |@|SSAS|__/@\\UU/:
s:S:   :g
y:@:\n:
s:U:_____:g

Grundlegende Codierung, speichert 3 Leerzeichen als S, \nals @und 5 Unterstreichungen als U. Ich werde weiterhin versuchen, Kombinationen zu finden, um etwas kürzeres zu finden.

Probieren Sie es online!

Die einfache Lösung zum direkten Drucken der Zeichenfolge ist unten angegeben. Es hat 136 Bytes, was zu einer Komprimierung von 18% unter Verwendung des obigen Kodierungsschemas führt.

c\  o\
       o\
    o\
 __________\
/          \\__\
|   J      |  \\\
|    A     |  |\
|     V    |  |\
|      A   |__/\
\\__________/

Probieren Sie es online!

MATL, 87 86 83 82 78 Bytes

[TIH][IAC]111Z?c'(ty!(OWM4J4gW{lm> >bw8ch|.FU2W"@\#2Dj!NQDeIMZ'F'_ /|\JAV'Za7e

Diese Lösung zerlegt den Kaffee in zwei Teile: die "Blasen" und die Tasse. Um die Blasen zu erzeugen, erstellen wir eine dünne Matrix mit 111 an drei Stellen und wandeln sie in ein Zeichenarray um

[TIH][IAC]111Z?c

Für die Becherkomponente setzen wir auf String-Komprimierung

'(ty!(OWM4J4gW{lm> >bw8ch|.FU2W"@\#2Dj!NQDeIMZ'F'_ /|\JAV'Za7e

Beide Komponenten werden auf die Ausgabe gedruckt, und zwischen den Komponenten wird automatisch eine neue Zeile eingefügt

Probieren Sie es bei MATL Online aus

Python 2 , 128 127 Bytes

-1 Byte dank Rod (Multiplikation des Tupels verwenden ('_'*10,), um eine Deklaration zu vermeiden).

print''.join('0'<c<':'and' '*int(c)or c for c in'''2o
7o
4o
 %s
/ 9\__
|3J6|2\\
|4A5|2|
|5V4|2|
|6A3|__/
\%s/'''%(('_'*10,)*2))

Probieren Sie es online!

Hinweis: dieser doppelte Backslash wird vor dem Zeilenvorschub benötigt.

Alles zwischen '''und '''ist eine einzelne Zeichenfolge, die beiden %ssind Formatierer, die durch den Inhalt des nachfolgenden %(...)Tupels ersetzt werden, das wiederum zwei Kopien '_'*10der Tupel-Multiplikation enthält (...)*2. Der '_'*10führt eine String-Multiplikation durch, um zu ergeben '__________'.

Der Code durchläuft die Zeichen, c, dieser ganze Reihe mit for c in '''...und erstellt eine neue Zeichenfolge durch Verbinden ( join(...))
entweder die Anzahl der Räume , die durch identifiziert c, int(c)wenn ceine Ziffer
oder c selbst
- wird eine Ziffer identifiziert wird durch '0'<c<':'über zu speichern c.isdigit().

Java 8, 294 289 248 Bytes

Golf gespielt:

()->{String s="";for(char c:"\u026F\n\u076F\n\u046F\n __________\n/\u0A5C__\n|\u034A\u067C\u025C\n|\u0441\u057C\u027C\n|\u0556\u047C\u027C\n|\u0641\u037C__/\n\\__________/".toCharArray()){for(int i=0;i<c>>8;++i)s+=' ';s+=(char)(c&255);}return s;}

Im Geiste der Kolmogorov-Komplexität wird der auszugebende String dadurch nicht hartcodiert . Stattdessen wird die Tatsache ausgenutzt, dass es in vielen Fällen mehrere Leerzeichen gibt, denen ein druckbares Zeichen folgt. Es codiert die Anzahl der Leerzeichen, die einem Zeichen im höherwertigen Byte des Zeichens vorangehen, und das tatsächliche ASCII-Zeichen im niederwertigen Byte.

Ungolfed:

import java.util.function.*;

public class DrinkYourMorningCoffee {

  public static void main(String[] args) {
    System.out.println(f(
    () -> {
      String s = "";
      for (char c : "\u026F\n\u076F\n\u046F\n __________\n/\u0A5C__\n|\u034A\u067C\u025C\n|\u0441\u057C\u027C\n|\u0556\u047C\u027C\n|\u0641\u037C__/\n\\__________/".toCharArray()) {
        for (int i = 0; i < c >> 8; ++i) {
          s += ' ';
        }
        s += (char) (c & 255);
      }
      return s;
    }
    ));
  }

  private static String f(Supplier<String> s) {
    return s.get();
  }
}

Befunge, 158 105 101 Bytes

<v"XaXXXNYXNY77777'XXXXX2_TXQXX0XZTXDXX0X^TXXRX0X^TXXDX07]27777#"p29+55
:<_@#:,g2/+55,g2%+55
\JV/|_Ao

Probieren Sie es online!

Die Zeichen in der Zeichenfolge werden zuerst als Indizes in eine Nachschlagetabelle der zehn möglichen Werte codiert. Die Indizes werden dann zu Paaren gruppiert, wobei jedes Paar zu einer einzigen Zahl (i1 + i2 * 10) im Bereich von 0 bis 99 kombiniert wird. Durch sorgfältige Auswahl der Reihenfolge der Nachschlagetabelle können wir sicherstellen, dass diese Werte immer gültig sind ASCII-Zeichen, die in einem String-Literal dargestellt werden können.

Dies ist eine Aufschlüsselung des Codes selbst:

Wir beginnen mit der Initialisierung des letzten Elements der Nachschlagetabelle mit einem Zeilenumbruchzeichen (ASCII 10).
Wir verwenden dann ein Zeichenfolgenliteral, um den codierten Inhalt auf den Stapel zu verschieben.
Schließlich durchlaufen wir die Werte des Stapels und dekodieren und geben jeweils zwei Zeichen aus.
Die letzte Zeile enthält die Nachschlagetabelle: Das 9. Element ist ein implizites Leerzeichen, und die 10. (neue Zeile) wird manuell festgelegt, wie bereits erläutert.

Retina , 71 Bytes

Anders als meine andere Antwort wurde diese von Hand geschrieben.

2o¶6o¶3o¶1=¶/55\__¶|3J6|2\¶|4A5|2|¶|5V4|2|¶|6A3|__/¶\=/
=
10$*_
\d
$* 

(Am Ende befindet sich ein Leerzeichen)

Probieren Sie es online!

Das Prinzip hat immer noch eine "komprimierte" Schnur, aus der die Tasse Kaffee durch Substitutionen rekonstruiert werden kann. Es stellte sich heraus, dass es sich nur lohnt, verschiedene Substitutionen zu versuchen:

• =wird zu __________(10 Unterstriche)
• Jede Ziffer wird zu dieser Anzahl von Leerzeichen

Common Lisp, 125 123 122 120 114 Bytes

(format t"~3@{~vto
~} ~10@{_~}
/~11t\\__
|   J~11t|  \\
~2@{|~5t~a~11t|  |
~}|~7tA   |__/
\\~10{_~}/"2 7 4'A" V"1)

Ich habe 6 Bytes gespart, indem ich die Idee hatte, nur Eingaben in eine Zeichenkette anstelle von ~&s zu schreiben.

Verbesserungsvorschläge erwünscht.

Python3, 206 Bytes

print('  o\n'+7*' '+'o\n'+4*' '+'o\n'+' '+10*'_'+'\n'+'/'+10*' '+'\__\n'+'|'+3*' '+'J'+6*' '+'|  \\\n'+'|'+4*' '+'A'+5*' '+'|  |\n'+'|'+5*' '+'V'+4*' '+'|  |\n'+'|'+6*' '+'A'+3*' '+'|__/\n'+'\\'+10*'_'+'/') 

Pyth, 80 Bytes

r"  o
7 o
4 o
 10_
/10 \__
|3 J6 |  \\
|4 A5 |  |
|5 V4 |  |
|6 A3 |__/
\\10_/"9

Online-Dolmetscher hier verfügbar.

Einfache Lauflängendekodierung.

C - 179

Lösung mit umfangreicher Verwendung von Formatstrings:

void f(){printf("%1$3c\n%1$8c\n%1$5c\n%2$11s\n/%3$13s\n|%4$4c%5$7c%6$3c\n|%7$5c%5$6c%5$3c\n|%8$6c%5$5c%5$3c\n|%7$7c%5$4c__/\n\\%2$s/\n",'o',"__________","\\__",74,'|',92,65,86);}

Hier ist eine besser lesbare Version:

void f() {
  printf("%1$3c\n"
         "%1$8c\n"
         "%1$5c\n"
         "%2$11s\n"
         "/%3$13s\n"
         "|%4$4c%5$7c%6$3c\n"
         "|%7$5c%5$6c%5$3c\n"
         "|%8$6c%5$5c%5$3c\n"
         "|%7$7c%5$4c__/\n"
         "\\%2$s/\n"
         'o',"__________","\\__",'J','|','\','A','V');
}

Retina , 99 Bytes

Diese Lösung wurde mithilfe dieses Skripts automatisch generiert .

0 0o¶ 1¶/32\__¶4 J24\¶|3A 34|¶| 3V34|¶|2A   |__/¶\1/
4
|  
3
    
2
      
1
__________
0
  o¶    

(in vielen Zeilen sind nachgestellte Leerzeichen)

Dies funktioniert, indem Zahlen 1, 2, 3, 4 anstelle einiger Zeichenfolgen verwendet werden, die in der Zielzeichenfolge wiederholt werden, und diese dann zurückgesetzt werden.

Ich weiß, dass man mehr Golf spielen könnte, wenn man diesen Code ändert oder die Herangehensweise komplett ändert, aber da die Kolmogorov-Meta-Golf-Herausforderung ein ziemlich enttäuschendes Ergebnis hatte, wollte ich versuchen, mein Skript für eine echte Herausforderung zu verwenden.

Probieren Sie es online!

Python 3.6

Hier ist mein Versuch der Huffman-Codierung. Es ist definitiv weiter golffähig, wenn jemand die Idee aufgreifen möchte.

from bitarray import bitarray as b
a=b()
a.frombytes(bytes.fromhex('ca7fca7e53b6db6db664ffc6d9ae1fd6335e2fad1af83d68d7e2e9b218db6db6db20'))
print(''.join(a.decode({k:b(v)for k,v in zip(" _|\no/\\AJV","1 011 010 0011 00101 00100 00011 00010 00001 00000".split())})))

Das Literal könnte noch weiter komprimiert werden, indem es in base64 oder ein anderes konvertiert wird, und der Huffman-Baum könnte optimiert werden, um noch ein kürzeres Bitarray zu erhalten.

GameMaker-Sprache, 138 Byte

show_message("  o#       o#    o# __________#/          \__#|   J      |  \#|    A     |  |#|     V    |  |#|      A   |__/#\__________/")

C 141 Bytes

f(){printf("  o\n%7co\n    o\n __________\n/%11c__\n|   J%6c|  \\\n|    A     |  |\n|%6c    |  |\n|%7c   |__/\n\\__________/",0,92,0,86,65);}

Verwendung

main(){f();}

Einfache Lösung, 148 Bytes:

w(){puts("  o\n       o\n    o\n __________\n/          \\__\n|   J      |  \\\n|    A     |  |\n|     V    |  |\n|      A   |__/\n\\__________/");}

PHP, 116 Bytes

for(;$c="1o
6o
3o
 9
/44\\__
|2J5|1\\
|3A4|1|
|4V3|1|
|5A2|__/
\\9/"[$i++];)echo$c>0?str_repeat(" _"[$c>8],$c+1):$c;

Das sieht Arnauld sehr ähnlich - und tut so ziemlich dasselbe. Laufen Sie mit -r.

zsh, 86 Bytes

printf "^_<8b>^H^@^@^@^@^@^B^CSPÈçR^@^A^P^CJÆÃ^A<97>¾^B^\Ä^@¹5@Ú^KÂ^E2cÀ|^EG^X¿^FÂW^HCæÃTÔÄÇësÅÀ^L^Fq^@<92>}ý^?{^@^@^@"|zcat

Erklärung: Diese Zeichenfolge ist die gzip-komprimierte Java Cup ASCII Art. Ich benutze printf, weil mit echo, zcateine Warnung ausgegeben wird und echo -eein Zeichen länger ist. Es funktioniert nicht mit bashoder sh, weil sie denken, es ist eine Binärdatei. Da Sie diese Ausgabe nicht effektiv aus dem Browser einfügen können, finden Sie hier eine verwendbare Datei.

Java 9 / JShell, 299 Byte

()->{String s="";BigInteger b=new BigInteger("43ljxwxunmd9l9jcb3w0rylqzbs62sy1zk7gak5836c2lv5t36ej6682n2pyucm7gkm9bkfbn4ttn0gltbscvbttifvtdfetxorj6mmy3mt6r3",36);while(!b.equals(BigInteger.ZERO)){int x=b.intValue()&0x3ff;for(int i=0;i<x>>7;i++)s+=' ';s+=(char)(x&0x7f);b=b.shiftRight(10);}return s;}

Ungolfed:

() -> {
    String s = "";
    BigInteger b = new BigInteger(
        "43ljxwxunmd9l9jcb3w0rylqzbs62sy1zk7gak5836c2lv5t36ej6682n2pyucm7gkm9bkfbn4ttn0gltbscvbttifvtdfetxorj6mmy3mt6r3",
        36);
    while (!b.equals(BigInteger.ZERO)) { 
        int x = b.intValue() & 0x3ff;
        for (int i = 0; i < x >> 7; i++) s+=' ';
        s += (char)(x&0x7f);
        b = b.shiftRight(10);
    }
    return s;
}

Verwendung in JShell:

Supplier<String> golf = <lambda expression>
System.out.println(golf.get())

Codiert jedes Zeichen als zehn Bits, bestehend aus der Anzahl der Leerzeichen vor dem Zeichen in den oberen drei Bits, gefolgt vom Codepunkt in den unteren sieben Bits.

(Da es nur drei Bits für die Zählung gibt, kann es nicht mehr als sieben aufeinanderfolgende Leerzeichen darstellen, und es gibt zehn Leerzeichen an einem Punkt in der Zeichenfolge. Diese werden als Anzahl von sechs codiert, gefolgt von einem Leerzeichen und dann einem Anzahl von drei, gefolgt vom nächsten Zeichen.)

Leider verliert es an dieser trivialen 140-Byte-Java-Lösung:

()->"  o\n       o\n    o\n __________\n/          \\__\n|   J      |  \\\n|    A     |  |\n|     V    |  |\n|      A   |__/\n\\__________/"

05AB1E , 85 Bytes

•1d'uì[_ÍpH»Ð]jŠ$ÿ{ɘß|ªpå±W¾Ö:ÞjÇ&@è$´Öàˆå]Á¢šBg¦ï&-ã¥ønØ7Ñà'?•9B8ÝJ"o _/\|JAV"‡15ô»

Probieren Sie es online!