diff --git a/OLD.d.ebene b/OLD.d.ebene
index 880a44c..9ee8640 100644
--- a/OLD.d.ebene
+++ b/OLD.d.ebene
@@ -11260,3 +11260,15 @@
 
 
 
+Papageien ... (Humni, 30. Jul 2018, 22:51:39):
+... lernen nun langsamer.
+
+Dies war aufgrund von ... oeh ... ich denke mal, akuter Ueberforderung leider
+notwendig.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.gilden.kaempfer b/OLD.gilden.kaempfer
index 2ab4821..c814996 100644
--- a/OLD.gilden.kaempfer
+++ b/OLD.gilden.kaempfer
@@ -32925,3 +32925,31 @@
 
 
 
+Re: Gilden-Aufwertung (Ark, 29. Jul 2018, 16:44:42):
+~#! rn=Notstrom rt=1532849494 rg=gilden.kaempfer
+~#! tid=1532849494
+Klar, Kemfa konnten ja bisher Tragheilung und Ruestung nicht auseinanderhalten
+:-D
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Gilden-Aufwertung (Ark, 29. Jul 2018, 16:47:45):
+~#! rn=Zaphob rt=1532859166 rg=gilden.kaempfer
+~#! tid=1532849494
+DT_FIRE gegen MAT_CHEESE? Ich weiss, wer gewinnt ... vor dem Tod kann der
+Kemfa noch Kaese-Fondue schlemmen.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.kochrezepte b/OLD.kochrezepte
index 85f6ef1..b94c170 100644
--- a/OLD.kochrezepte
+++ b/OLD.kochrezepte
@@ -12382,3 +12382,42 @@
 
 
 
+Nussecken (vegan) (Zesstra, 16. Sep 2018, 19:37:30):
+Am Wochenende wollte jemand das Rezept fuer vegane Nussecken haben, daher
+kommt das nun hier hinein.
+
+Nussecken:
+---------
+Teig:
+70 g Alsan (Bio)
+70 g Rohrohrzucker
+1 Pck. Vanillezucker
+150 g Mehl
+1 EL Sojamehl
+2 EL Wasser
+
+Belag:
+100 g Rohrohrzucker
+100 g Alsan
+1 Pck. Vanillezucker
+2 EL Wasser
+200 g Haselnusse (gemahlen oder halb-halb gemahlen und gehackt)
+100 g Zartbitterschokolade (milchfrei, optional fr Verzierung)
+Aprikosenmarmelade
+
+Teigzutaten verkneten, ausrollen und mit Marmelade dnn bestreichen
+Belagzutaten vermengen und verkneten, zuerst trockene Zutaten, dann Alsan und
+dann Wasser
+Belag auf dem Teig verteilen
+Bei 175C 20-30min backen
+Auskhlen lassen und lauwarm in Dreiecke schneiden
+Dreiecke mit Schokolade nach Wunsch verzieren
+
+Quelle: https://www.tierbefreiungsoffensive-saar.de/rezepte/
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.party b/OLD.party
index 7429af9..87e1666 100644
--- a/OLD.party
+++ b/OLD.party
@@ -80761,3 +80761,168 @@
 
 
 
+Pizzabestellung fuer Partyabend (Zesstra, 30. Jul 2018, 10:34:01):
+Huhu...
+
+damit wir naechstes Jahr eine Referenz haben, was dieses Jahr gut ging,
+sollten wir mal aufschreiben, was wir hatten. ;-)
+Wir hatten 10 Bleche Pizza fuer 27 Personen.
+* 2 Spinat-Gorgonzola
+* 2 Paprika,Mais,Zwiebeln,Knoblauch, Feta
+* 1.5 Salami
+* 0.5 Margarita
+Das war meine Erinnerung: kann das jemand speziell fuer den
+nicht-vegetarischen Bereich ergaenzen? ;-)
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Pizzabestellung fuer Partyabend (Croft, 30. Jul 2018, 10:57:34):
+~#! rn=Zesstra rt=1532939641 rg=party
+~#! tid=1532939641
+Korrektur: 26 Personen und 1 Kind. Die 27. Person ist nicht bis zur Party
+geblieben.  Hatte mir das auch schon grob in der Abrechnung notiert.
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Pizzabestellung fuer Partyabend (Gloinson, 30. Jul 2018, 11:04:11):
+~#! rn=Croft rt=1532941054 rg=party
+~#! tid=1532939641
+Die 27. Person musste allein schon deshalb gehen, weil einige Anwesende
+befuerchteten, dass sie mindestens zehn Bleche allein leerfressen wuerde.
+
+Vielen Dank an die Orga!
+
+
+-----------------------------------------------------------------------------
+
+
+
+Wadenstecher (Gloinson, 30. Jul 2018, 11:10:08):
+https://de.wikipedia.org/wiki/Wadenstecher
+
+"Wird eine Blutmahlzeit an einem infizierten Tier oder Menschen unterbrochen,
+koennen sie an ihren Mundwerkzeugen haftendes infektioeses Blut auf kurze
+Distanz innerhalb von etwa 30 Minuten auf ein benachbartes, noch nicht
+infiziertes Tier oder einen Menschen uebertragen."
+
+und auch
+
+"Beim Nutzvieh kann das Blutsaugen zu einer Verringerung des Milchertrages und
+des Fleisch- und Fettansatzes fuehren ..."
+
+Letzteres duerfte fast eine gute Nachricht fuer das MUD-Nutzvieh 'Spieler'
+sein.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Pizzabestellung fuer Partyabend (Deaddy, 30. Jul 2018, 11:11:18):
+~#! rn=Gloinson rt=1532941451 rg=party
+~#! tid=1532939641
+Ich moechte da auch meinen Dank aussprechen, das war sehr schoen und fuer die
+folgenden MUD-Parties plane ich auch schonmal einen laengeren Aufenthalt ein!
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Pizzabestellung fuer Partyabend (Soynada, 30. Jul 2018, 11:49:55):
+~#! rn=Deaddy rt=1532941878 rg=party
+~#! tid=1532939641
+Ich moechte mich auch ganz herzlich fuer die schoene Party bedanken!
+
+@Pizzabestellung: Es war auf jeden Fall noch Hawaii und Schinken+Pilze dabei,
+ich weiss aber nicht, wie viel jeweils.
+
+@Eis: Der Eismann ist unter der Telefonnummer 0178/5049500 oder der
+E-Mail-Adresse bochumeis@gmail.com zu erreichen, falls wir mal wieder in
+Hattingen auf dem Campingplatz sitzen und gerne Eis haetten.
+
+Soynada
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Pizzabestellung fuer Partyabend (Zook, 30. Jul 2018, 12:00:46):
+~#! rn=Soynada rt=1532944195 rg=party
+~#! tid=1532939641
+Ja, vielen herzlichen Dank an die Orga fuer die schoene Party!
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Pizzabestellung fuer Partyabend (Vanir, 30. Jul 2018, 12:14:11):
+~#! rn=Zook rt=1532944846 rg=party
+~#! tid=1532939641
+Ja auch hier nochmal: Es hat sehr viel Spass gemacht und ich danke allen, was
+auch immer sie organisiert haben. 
+
+Ich hab uebrigens einen USB-Stick Marke Platinum gefunden. 
+
+V.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Pizzabestellung fuer Partyabend (Miril, 30. Jul 2018, 19:08:26):
+~#! rn=Zesstra rt=1532939641 rg=party
+~#! tid=1532939641
+Es waren folgende Pizzen (auch aus dem Gedaechtnis):
+2x Paprika, Mais, Zwiebeln, Knoblauch, Feta
+2.5 x Spinat, Gorgonzola
+1.5 Salami
+0.5 Schinken, Champignon
+1.5 Hawai
+0.5 Rucola, Parmesan, Tomaten (leider ohne Rucola)
+0.5 Lachs und anderer Kram
+0.5 -1 Schinken
+
+Miril
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Pizzabestellung fuer Partyabend (Notstrom, 30. Jul 2018, 19:36:13):
+~#! rn=Zook rt=1532944846 rg=party
+~#! tid=1532939641
+Ganz dollen Dank an die Orga, und auch nochmal ganz lieben Dank fuers Zelt
+ausborgen und die Hilfe bei Auf- und Abbau. Die Woche hat mir wieder sehr
+gut gefallen.
+Uebrigens war auch Jutta (die Besitzerin des Zeltplatzes) sehr angetan von
+der Morgengrauen-Gruppe als Ganzem. Wir scheinen alles richtig gemacht zu
+haben, denn sie sagte, sie freue sich schon auf naechstes Jahr und wir
+sollten unbedingt wiederkommen.
+
+Notstrom.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Pizzabestellung fuer Partyabend (Croft, 30. Jul 2018, 22:40:11):
+~#! rn=Gloinson rt=1532941451 rg=party
+~#! tid=1532939641
+Du warst nicht die 27. Person :p
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
