diff --git a/documents/Philosophers-Report-RodriguezBrandon.tex b/documents/Philosophers-Report-RodriguezBrandon.tex
new file mode 100644
index 0000000000000000000000000000000000000000..3cbc44e78fd1883ad7386452a311723c01b24af2
--- /dev/null
+++ b/documents/Philosophers-Report-RodriguezBrandon.tex
@@ -0,0 +1,66 @@
+\documentclass[a4paper,12pt]{article}
+
+
+% For latex basics, see http://www.docs.is.ed.ac.uk/skills/documents/3722/3722-2014.pdf.
+% For help on symbols, see https://oeis.org/wiki/List_of_LaTeX_mathematical_symbols.
+% For info on state machines, look up youtube "Neso Academy" channel.
+
+
+% Import Packages.
+% Multi-column package. Allows formatting in columns.
+\usepackage{multicol}
+
+
+% Adjust page margins to not be so excessive.
+\addtolength{\oddsidemargin}{-.2in}
+\addtolength{\evensidemargin}{-.2in}
+\addtolength{\textwidth}{.4in}
+\addtolength{\topmargin}{-.8in}
+\begin{document}
+	\title{CS5541 - Dining Philosophers}
+	\author{Brandon Rodriguez}
+	\date{\today}
+	\maketitle
+	
+	In all of the following implementations, each thread is considered a "Philosopher". Each thread will attempt to grab forks, and when it has two forks, it will take a single "bite". After 1000 bites, the thread is considered "full" and will not eat or access forks further.
+
+	\section{Correct Implementation}
+	\vspace{-4ex}~
+	
+	Compiled and executed via "\textbf{make correct}" in terminal.\\
+
+	It's easiest to start by describing how to implement the "correct" (no starvation or deadlock) implementation. For this, I started by making threads that are given a unique thread number, starting at 0.\\
+	
+	Once initialized, all threads are set up and ready, they start attempting to "eat". This is done by each thread attempting to get a left and right fork. After the attempt, the thread checks if it was able to grab both forks. If it wasn't, it puts down any forks it currently holds. If it did grab both forks, then it "takes a bite" and then puts the forks back down. Each fork is guarded by a unique mutex variable to make accessing and releasing threadsafe.\\
+	
+	This repeats until all threads "are full" and thus done eating. As more threads finish, it becomes easier for the remaining threads to grab forks and also finish.
+	
+	\section{Deadlock Implementation}
+	\vspace{-4ex}~
+	
+	Compiled and executed via "\textbf{make deadlock}" in terminal.\\
+	
+	The deadlock implementation will occassionally deadlock. This is accomplished by copying the original "correct implementation" code, and then adjusting it slightly.\\
+	
+	In this version, the program will work the same up until threads pick up a fork. In this version, they will hold onto the fork unconditionally, regardless of if they were able to grab two or not.\\
+	
+	Then, if the thread had two forks, it will eat and put the forks back down. If the thread did not have two forks, it will just keep trying to grab two forks until it succeeds.\\
+	
+	This can easily result in all threads picking up a single fork. They will each hold onto their single fork while attempting to grab more. But since no threads are putting the forks back down, there are no more forks to grab. Deadlock occurs.
+
+	\section{Starvation Implementation}
+	\vspace{-4ex}~
+	
+	Compiled and executed via "\textbf{make starvation}" in terminal.\\
+	
+	The starvation implementation will basically always starve out one or more threads until some others complete. This is accomplished by copying the original "correct implementation" code, and then adjusting it slightly.\\
+	
+	In this version, the program will work the same up until the threads eat. In this version, the threads will hold onto the forks even after taking a bite. They don't put the forks back down until 100\% done eating. Thus the threads directly adjacent will be unable to eat for the entire duration of the thread's life. The result is that some threads will be very low in bite count while others are finishing up.\\\\\\
+	
+	Note that the "correct" implmentation seems to generally have all threads at roughly the same bite count (at least on my machine), and thus is "starvation free". However, in some runs, thread execution order does still result in some threads being as low as 500 bite count while others are finishing up. But not usually.\\
+	
+	To correct this, the program would need to have an additional threading metric that tracks how many bites each philosopher has. Then fork priority can be given to some threads over others, based on this metric.\\
+	
+	Having said that, the "starvation" implementation is still much worse. It has "true starvation" where a thread won't get any bites at all until another one is fully complete.
+
+\end{document}
\ No newline at end of file
diff --git a/documents/Philosophers-Report_RodriguezBrandon.pdf b/documents/Philosophers-Report_RodriguezBrandon.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..7159235e5368d81df4fff60b5cdaad7b2b34b71f
Binary files /dev/null and b/documents/Philosophers-Report_RodriguezBrandon.pdf differ
diff --git a/documents/dining.pdf b/documents/Project_Instructions.pdf
similarity index 100%
rename from documents/dining.pdf
rename to documents/Project_Instructions.pdf
diff --git a/readme.md b/readme.md
index fef1a9888ef77a9c669d02eef1f7addb998722cc..179f82e6176d6d685957e1c74fe7d63fa5e62184 100755
--- a/readme.md
+++ b/readme.md
@@ -11,5 +11,9 @@ For a list of available makefile commands, run `make help`.<br>
 In a terminal, run `make <command_here>`.
 
 
+## Report
+See `documents/Philosophers-Report.pdf`.
+
+
 ## References
 See `documents/references.md`.