diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index 343ba14..63d0c67 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
diff --git a/OLD.party b/OLD.party
index 784f2d8..0353686 100644
--- a/OLD.party
+++ b/OLD.party
@@ -82543,3 +82543,39 @@
 
 
 
+Re^31: SOMMERPARTY IN HATTINGEN! (Humni, 16. Jul 2020, 09:40:28):
+~#! rn=Nondrum rt=1594560102 rg=party
+~#! tid=1581278427
+In bewaehrter Megaschmarrn-Tradition (die Leser davon wissen das auch schon,
+da die immer mehr wissen) antworte ich auf den letzten Artikel.
+
+Fuer die Partywoche sagt Kachelmannwetter derzeit:
+
+* Die 40 Grad werden wir nicht knacken dieses Jahr. Vermutlich nichtmal die
+30. Finde ich jetzt nicht soo tragisch ...
+* Es wird am Montag vermutlich regnen. Womoeglich auch am Samstag, aber die
+Prognose ist natuerlich noch ueber eine Woche hin, ob die stimmt, ist hoechst
+fraglich, zumal nichtmal alle Wettermodelle das sagen.
+
+Soviel zum derzeitigen Stand. Ob das so bleibt, ist natuerlich auch nicht klar
+- auch bis Montag sind das noch ein paar Tage, da koennen auch alle Modelle
+mal danebenliegen.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^32: SOMMERPARTY IN HATTINGEN! (Gloinson, 16. Jul 2020, 23:32:39):
+~#! rn=Humni rt=1594885228 rg=party
+~#! tid=1581278427
+
+Das waer mal 'ne angenehme Abwechslung, wenn man das Wasser nicht aus dem
+Thermobecher trinken muss.
+
+
+-----------------------------------------------------------------------------
+
+
+
