diff --git a/README.md b/README.md
index ac4e0e68240b46711575d11df560fab630caa2dd..f2d42c6ce3c9c892812189aa13d6fc1a878bd54f 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
 
 După ce și-a făcut atâția prieteni în cadrul temei 2, suricata Zoly a efectuat un audit de securitate al rețelelor clanurilor cărora s-a alăturat și și-a dat seama că nu există nicio măsură adecvată de securitate. Astfel, ea dorește să își creeze propriul sistem de detecție si prevenire a intruziunilor in rețea, si vă roagă să o ajutați cu implementarea unor componente ale acestuia.
 
-## Task 1 - Parantezinatorul
+## Task 1 - Parantezinator
 
 Sistemul se bazează pe anumite reguli care trebuie scrise într-un fișier de configurare.
 Un aspect important al verificării acestor reguli este parantezarea diferitelor elemente ale regulii.
@@ -130,7 +130,7 @@ Printarea se va realiza prin apelara funcției `printf`.
 | Folosire macro PRINTF32 | -10p |
 | Soluție nerecursivă | -20p |
 
-## Bonus
+## Bonus - x64 assembly
 
 Acum ca Zoly și-a scris sistemul de detecție a intruziunilor și își poate apăra toți prietenii pe care și i-a facut în tema 2, se poate întoarce la marea ei pasiune: programarea funcțională.
 
diff --git a/src/bonus/README.md b/src/bonus/README.md
index dbd6f6769e2089bbc48e21a2a16a5d48673d1a3c..34c86bd22f80006f0c4769b29a22205d2fa6595b 100644
--- a/src/bonus/README.md
+++ b/src/bonus/README.md
@@ -1,51 +1,51 @@
-# Bonus - x64 assembly
+## Bonus - x64 assmebly
 
-Acum ca Zoly si-a scris sistemul de detectie a intruziunilor
-si isi poate apara toti prietenii pe care si i-a facut in tema 2,
-se poate intoarce la marea ei pasiune: programarea functionala.
+Acum ca Zoly și-a scris sistemul de detecție a intruziunilor și își poate apăra toți prietenii pe care și i-a facut în tema 2, se poate întoarce la marea ei pasiune: programarea funcțională.
 
-Totodata, spre deosebire de echipa de PCLP2, ea a inteles ca in
-prezent se folosesc sisteme pe 64 de biti, iar cele pe 32 de biti
-sunt foarte rare. Astfel, ea doreste sa implementeze functiile
-`map` si `reduce` in assembly pe 64 de biti si folosin si numere
-pe 64 de biti. Stiti de la
-(tema 1)[https://gitlab.cs.pub.ro/iocla/tema-1-2024] ce sunt fiecare.
+Totodată, spre deosebire de echipa de PCLP2, ea a înțeles că în prezent se folosesc sisteme pe 64 de biți, iar cele pe 32 de biți sunt foarte rare. Astfel, ea dorește să implementeze funcțiile `map` și `reduce` în assembly pe 64 de biți si folosim și numere pe 64 de biți. Stiți de la [tema 1](https://gitlab.cs.pub.ro/iocla/tema-1-2024) ce sunt fiecare.
 
 ## Map
 
 Antet map:
-```
+
+```c
 void map(int64_t *destination_array, int64_t *source_array, int64_t array_size, int64_t(*f)(int64_t));
 ```
 
 Antet functie ce poate fi folosita pentru map:
-```
+
+```c
 int64_t map_func1(int64_t curr_elem);
 ```
 
 Pseudocod map:
-```
+
+```text
 map(dst, src, n, to_apply):
-	for i de la 0 la n:
-		dst[i] = to_apply(src[i])
+    for i de la 0 la n:
+        dst[i] = to_apply(src[i])
 ```
 
 ## Reduce
 
 Antet reduce:
-```
-int64_t fold(int64_t *destination_array, int64_t *source_array, int64_t array_size, int64_t accumulator_initial_value, int64_t(*f)(int64_t, int64_t));
+
+```c
+int64_t reduce(int64_t *destination_array, int64_t *source_array, int64_t array_size, int64_t accumulator_initial_value, int64_t(*f)(int64_t, int64_t));
 ```
 
 Antet functie ce poate fi folosita pentru reduce:
-```
+
+```c
 int64_t reduce_func1(int64_t accumulator, int64_t current_elem);
 ```
 
 Pseudocod reduce:
-```
+
+```text
 reduce(src, n, accumulator_initial, to_apply):
-	acc = accumulator_initial
-	for i de la 0 la n:
-		acc = to_apply(acc, src[i])
+    acc = accumulator_initial
+    for i de la 0 la n:
+        acc = to_apply(acc, src[i])
+    return acc
 ```
diff --git a/src/task-1/README.md b/src/task-1/README.md
index 57ab50ba882c0823baa14eaa71d7b68b3bdec22b..8607bf22633355478bcde211d1db9410d7618879 100644
--- a/src/task-1/README.md
+++ b/src/task-1/README.md
@@ -1,18 +1,10 @@
-# Task 1 - Paranthesinator
+## Task 1 - Parantezinator
 
-Sistemul se bazează pe anumite reguli care trebuie scrise intr-un
-fișier de configurare.
-Un aspect important al verificării acestor reguli este parantezarea
-diferitelor elemente ale regulii.
+Sistemul se bazează pe anumite reguli care trebuie scrise într-un fișier de configurare.
+Un aspect important al verificării acestor reguli este parantezarea diferitelor elemente ale regulii.
 
-În acest task va trebui să implementați o funcție care verifică
-dacă un șir de paranteze formează o parantezare corectă, adică
-dacă toate parantezele deschise sunt inchise corespunzător.
+În acest task va trebui să implementați o funcție care verifică dacă un șir de paranteze formează o parantezare corectă, adică dacă toate parantezele deschise sunt închise corespunzător.
 
-De exemplu, șirul "()()" este o parantezare corectă, dar
-"{{}" nu este, pentru ca se Închide doar o paranteză,
-și nici "{[}]" nu este, pentru că parantezele nu sunt
-Închise corespunzător.
+De exemplu, șirul "()()" este o parantezare corectă, dar "{{}" nu este, pentru ca se închide doar o paranteză, și nici "{[}]" nu este, pentru că parantezele nu sunt închise corespunzător.
 
-Funcția pe care o veți implementa va returna 0 daca nu sunt probleme
-de parantezare (dacă sunt parantezele puse bine) si 1 altfel.
+Funcția pe care o veți implementa va returna 0 daca nu sunt probleme de parantezare (dacă sunt parantezele puse bine) si 1 altfel.
diff --git a/src/task-2/README.md b/src/task-2/README.md
index bfbadf6590a665cd68fb50323f977146884315a8..836c488e617435091b302086664b4443fdc679ff 100644
--- a/src/task-2/README.md
+++ b/src/task-2/README.md
@@ -1,13 +1,10 @@
-# Task 2 - Divide et impera
+## Task 2 - Divide et impera
 
-În acest task veți implementa doi algoritmi bine cunoscuți (sperăm noi):
-*quick sort* și *binary search*.
+În acest task veți implementa doi algoritmi bine cunoscuți (sperăm noi): *quick sort* și *binary search*.
 
 *Note:* ambele implementări trebuie să fie recursive, NU iterative.
 
-Pentru a rula toate testele, rulați executabilul generat fară niciun
-argument. Pentru a rula un singur test, pasati unul dintre keyword-urile
-`qsort` și `bsearch` ca prim argument, urmat de numărul testului.
+Pentru a rula toate testele, rulați executabilul generat fară niciun argument. Pentru a rula un singur test, pasati unul dintre keyword-urile `qsort` și `bsearch` ca prim argument, urmat de numărul testului.
 De exemplu:
 
 ```bash
@@ -21,14 +18,11 @@ $ ./checker bsearch 10
 
 ---
 
-## Exercițiul 1
+### Exercițiul 1
 
-Pentru acest exercițiu aveți de implementat funcția `quick_sort()` în fișierul
-`subtask_1.asm`.
+Pentru acest exercițiu aveți de implementat funcția `quick_sort()` în fișierul `subtask_1.asm`.
 
-Această funcție are semnătura de mai jos. În urma rulării ei, numerele stocate
-în `buff` vor fi sortate crescător. `start` și `end` reprezintă indexul
-primului, respectiv ultimului element (Începând de la 0).
+Această funcție are semnătura de mai jos. În urma rulării ei, numerele stocate în `buff` vor fi sortate crescător. `start` și `end` reprezintă indexul primului, respectiv ultimului element (începând de la 0).
 
 ```c
 void quick_sort(int32_t *buff, uint32_t start, uint32_t end);
@@ -36,23 +30,16 @@ void quick_sort(int32_t *buff, uint32_t start, uint32_t end);
 
 ---
 
-## Exercițiul 2
+### Exercițiul 2
 
-În acest exercițiu va trebui sa implementați funcția `binary_search()` în
-fișierul `subtask_2.asm`.
+În acest exercițiu va trebui sa implementați funcția `binary_search()` în fișierul `subtask_2.asm`.
 
-Această funcție va returna poziția elementului `needle` in cadrul array-ului
-`buff`. Căutarea va avea loc între elementele indexate `start` și `end`
-(inclusiv). Dacă `needle` nu se găsește în `buff`, funcția va returna `-1`.
-Este garantat faptul că elementele din `buff` sunt sortate crescător.
+Această funcție va returna poziția elementului `needle` in cadrul array-ului `buff`. Căutarea va avea loc între elementele indexate `start` și `end` (inclusiv). Dacă `needle` nu se găsește în `buff`, funcția va returna `-1`. Este garantat faptul că elementele din `buff` sunt sortate crescător.
 
-Observați în cadrul semnăturii funcției atributul
-[fastcall](https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html).
-Acesta va modifica calling convention-ul utilizat in `check.c`. Țineți cont de
-acest lucru când implementați funcția (și când faceți apelurile recursive).
+Observați în cadrul semnăturii funcției atributul [fastcall](https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html).
+Acesta va modifica calling convention-ul utilizat in `check.c`. Țineți cont de acest lucru când implementați funcția (și când faceți apelurile recursive).
 
 ```c
 int32_t __attribute__((fastcall))
 binary_search(int32_t *buff, uint32_t needle, uint32_t start, uint32_t end);
 ```
-