diff --git a/report/document.pdf b/report/document.pdf
index 856ca2d..3b3f209 100644
Binary files a/report/document.pdf and b/report/document.pdf differ
diff --git a/report/document.tex b/report/document.tex
index ae2a77c..301645f 100644
--- a/report/document.tex
+++ b/report/document.tex
@@ -307,11 +307,11 @@ The class \texttt{Stencil} holds both the parallel implementation using the Fast
 
 The class \texttt{Reader} reads a binary file composed of 4 bytes representing the number of rows, 4 bytes representing the number of columns and then the raw matrix data. Each element is a \texttt{char} in all the test cases. The result is stored in the class \texttt{Task} which will be passed to the next node. If instead the operator \texttt{()} is called, only the data will be returned as a pointer.
 
-The \texttt{Task} class can support matrixes of different element type rather than \texttt{char}.
+The \texttt{Task} class can support matrices of different element type rather than \texttt{char}.
 
 The \texttt{Writer} instead writes to disk the task to the same folder, overwriting existing files if present.
 
-The \texttt{Stencil} class divides the matrix in rougly equal parts and distributes them to other workers.
+The \texttt{Stencil} class divides the matrix in roughly equal parts and distributes them to other workers.
 
 %% - - - - - - - - - - - - - - - - - - %%
 \subsection{Native C++ Threads}
@@ -457,7 +457,7 @@ the fastflow has a peek of speedup and scalability when using 4 workers in the s
 \end{center}
 
 The file \texttt{random400x2500} % chktex 29
-performs best with 16 workers in the Fastflow implementation and slightly better at 64 workers compared to 32 workers in terms of speedup and scalability but has a significand drop in efficiency from $0.361$ to $0.184$. The relationship between number of workers and speedup is close to linear up to 8 workers.
+performs best with 16 workers in the Fastflow implementation and slightly better at 64 workers compared to 32 workers in terms of speedup and scalability but has a significant drop in efficiency from $0.361$ to $0.184$. The relationship between number of workers and speedup is close to linear up to 8 workers.
 
 \begin{center}
   \begin{tikzpicture}
@@ -483,11 +483,11 @@ The file \texttt{equation} more closely follows a linear relationship between sp
   \end{tikzpicture}
 \end{center}
 
-As the size of the input increases the speedup and the scalability both follow linear trends up with a higher ammount of threds.
+As the size of the input increases the speedup and the scalability both follow linear trends up with a higher amount of threads.
 
 The scalability for both test files \texttt{equation} and \texttt{equation2} never go below $0.37$, but is slightly better for the implementation with native C++ threads.
 
-The difference in the three quantities between the test with file \texttt{equation} and the test with file \texttt{euqation1} is much smaller for the Fastflow version. In the native thread version instead there is a small improvement expecially with a higher number of workers.
+The difference in the three quantities between the test with file \texttt{equation} and the test with file \texttt{equation1} is much smaller for the Fastflow version. In the native thread version instead there is a small improvement especially with a higher number of workers.
 
 \end{document}