diff --git a/aufgaben/blatt05/blatt05.md b/aufgaben/blatt05/blatt05.md
index a5f76745f73e43f04e0bd69c99f9cc84fa3c1362..a475930f7fa8ce32fddc26ecbcd37c2dfb9599d9 100644
--- a/aufgaben/blatt05/blatt05.md
+++ b/aufgaben/blatt05/blatt05.md
@@ -1,11 +1,11 @@
 Title: Blatt 4
 status: hidden
 
-# Parallelrechnerarchitekturen 2
+# Superlinearer Speedup und Vektorbefehle 
 
 Führen Sie vor dem Bearbeiten des Blattes wieder ein *git pull* durch.
 
-## Aufgabe 2: Superlinearer Speedup (*Abgabe war verschoben von Blatt 04*)
+## Aufgabe 1: Superlinearer Speedup (*Abgabe war verschoben von Blatt 04*)
 
 Auf der englischen Wikipedia unter wird folgende Aussage zum Thema 
 [superlinearer Speedup](https://en.wikipedia.org/wiki/Speedup#Super-linear_speedup)  bei
@@ -39,7 +39,7 @@ Problem löst und das bei  paralleler Bearbeitung auf einer gem5 Konfiguration m
   Sie den DDR-RAM in der Beispielkonfiguration durch ein SimpleMemory ersetzen 
   und die Parameter latency und bandwidth setzen. 
 
-
+- Unter umständen muss das Programm eine Zeit lang laufen um den gewünschten superlinearen Speedup zu zeigen.
 
 ### Abgabe
   
@@ -48,6 +48,100 @@ Problem löst und das bei  paralleler Bearbeitung auf einer gem5 Konfiguration m
 
 
 
+## Aufgabe 2:  SIMD Parallelismus ARM-Neon
+
+Sie haben in der Vorlesung bereits von
+SIMD (Single Instruction Multiple Data) oder auch Vektor-Einheiten von
+Prozessoren gehört. Dabei handelt es sich um Erweiterungen der eigentlichen
+Prozessorarchitektur um eine Komponente, die eine Berechnung gleichzeitig auf
+mehr als einem Datum ausführen kann (z.B. Vektoraddition).
+
+*Neon* ist die SIMD-Erweiterung der ARM-Architektur. Aus
+Programmierer-Sicht besteht die Neon-Erweiterung des ARM-Befehlssatzes aus einer
+Menge spezieller Assembler-Befehle. Darüber hinaus existiert auch ein
+High-Level Interface, welches es dem Programmierer auf
+einfache Art und Weise erlaubt, aus Sprachen wie C oder C++ heraus die
+Neon-Funktionalität zu benutzen.
+
+In dem Programm *neon_convert.c* wurde eine Funktion zur Konvertierung
+von Farbbildern in Graustufen einmal wie im folgenden in reinem C implementiert
+
+
+    void reference_convert (uint8_t * __restrict dest, uint8_t * __restrict src, int n){
+      int i;
+      for (i=0; i<n; i++){
+       int r = *src++; // load red
+       int g = *src++; // load green
+       int b = *src++; // load blue 
+
+       // build weighted average:
+       int y = (r*77)+(g*151)+(b*28);
+
+       // undo the scale by 256 and write to memory:
+       *dest++ = (y>>8);
+      }
+    }
+
+
+Und einmal mit neon intrinsics implementiert. 
+
+
+
+
+   void neon_convert (uint8_t * __restrict dest, uint8_t * __restrict src, int n){
+     int i;
+     uint8x8_t rfac = vdup_n_u8 (77);
+     uint8x8_t gfac = vdup_n_u8 (151);
+     uint8x8_t bfac = vdup_n_u8 (28);
+     n/= 8;
+
+     for (i=0; i<n; i++) {
+       uint16x8_t  temp;
+       uint8x8x3_t rgb  = vld3_u8 (src);
+       uint8x8_t result;
+
+       temp = vmull_u8 (rgb.val[0],      rfac);
+       temp = vmlal_u8 (temp,rgb.val[1], gfac);
+       temp = vmlal_u8 (temp,rgb.val[2], bfac);
+
+       result = vshrn_n_u16 (temp, 8);
+       vst1_u8 (dest, result);
+       src  += 8*3;
+       dest += 8;
+     }
+   }
+ 
+
+Ihre Aufgabe ist es nun die beiden implementierungen miteinander zu vergleichen und den Effekt von Pipelinebreiten und Compileroptimierungen auf 
+die Performance der implementierungen zu untersuchen. Übersetzen sie das Programm für den Simulator verwenden sie dazu die folgende Kommandozeile:
 
 
+    arm-linux-gnueabihf-gcc -O$optlevel -march=armv7-a -marm -mfpu=neon -mfloat-abi=softfp -static neon_convert.c -o neon_convert
+
+Ausführen lässt sich das Programm dann mittels: 
+
+    ~/parallel_computer_architecture/gem5/build/ARM/gem5.fast  MCConfig.py  -c "neon_convert -r" -w $w
+
+Für die referenzimplementierung und mittels:
+
+     ~/parallel_computer_architecture/gem5/build/ARM/gem5.fast  MCConfig.py  -c "neon_convert" -w $w
+
+Für die implementierung mit Neon intrinsics. "$w" steht in diesem Fall für die breite der Pipeline.
+
+Führen Sie Messungen für Pipelinebreiten zwischen 1 und 8 und die Optimierungsstufen 1 und 3 durch. 
+
+
+### Fragen 
+
+- Die Neon Erweiterung erlaubt es im Beispiel die Berechnung auf Vektoren der Länge acht durchzuführen. Wie hoch wäre hier der von ihnen erwartete Speedup?
+
+- Wie Sind die tatsächlichen Speedups. 
+
+- Versuchen sie mögliche Unterschiede zu den erwarteten Werten zu erklären. 
+
+
+### Abgabe
+  
+1.  die Ergebnisse der durchgeführten Messungen sowie die Erhaltenen fragen.      
+2.  die Antworten auf die Fragen