diff --git a/OLD.hardsoftware b/OLD.hardsoftware
index 1cb48cc..f22ace1 100644
--- a/OLD.hardsoftware
+++ b/OLD.hardsoftware
@@ -78255,3 +78255,46 @@
 
 
 
+Empfehlung Webcam (Zook,  3. Dez 2020, 13:40:32):
+Hey, ich suche eine Webcam fuer einen Nutzer mit Notebook, wo 
+es keine interne gibt. Also irgendwie USB Anschluss und dass man sie
+ggf. aufstecken kann, waere doll. Wird nur fuer Videokonferenzen
+gebraucht, muss also nicht hoellengut sein. Zook
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Empfehlung Webcam (Anthea,  3. Dez 2020, 14:10:22):
+~#! rn=Zook rt=1606999232 rg=hardsoftware
+~#! tid=1606999232
+Gibt es viele ;)
+Worauf man achten sollte. Es gibt meist "widescreen" Kameras mit 110°
+Aufnahmewinkel, und relativ regulaere mit 65°-75° Aufnahmewinkel. Die mit 110°
+haben zwar ein wunderbar breites Bild, sorgen aber auch fuer heftige
+Verzerrungen im Hintergrund des Bildes. Ich hatte jetzt ein paar getestet,
+"BENEWY" mit 110°, "ZLINK" mit 75°, "VESSTT" mit 100°. Alle so um die 20-40
+Euro. Von der Bild- und Tonqualitaet fand ich alle vollkommen in Ordnung. Das
+Bild an sich hat mich im Gegensatz zu den alten Cams begeistert, mit Full-HD,
+extrem guter Lichtausbeute, kein Problem mit Gegenlicht... das war aber auch
+bei allen so. Die ZLINK hat bei Aufnahmen in den Raum hinein den Vorteil, dass
+die geraden Waende einigermassen gerade bleiben, die Wand/Decke-Kante war bei
+den anderen sehr merklich gebogen. Die BENEWY und die ZLINK haben beide an der
+Halterung ein Standard-Schraubgewinde fuer Stative, das erweitert die
+Nutzungs- und Aufstellungsmoeglichkeit dann noch mal.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Empfehlung Webcam (Zook,  3. Dez 2020, 14:20:29):
+~#! rn=Anthea rt=1607001022 rg=hardsoftware
+~#! tid=1606999232
+Prima! Das ist mir eine grosse Hilfe. Danke!
+
+Zook
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index 0dcde92..39f2273 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
