diff --git a/eventloop/quiz/fytd-poll-immediate.txt b/eventloop/quiz/fytd-poll-immediate.txt
index 55bbf64..f47f971 100644
--- a/eventloop/quiz/fytd-poll-immediate.txt
+++ b/eventloop/quiz/fytd-poll-immediate.txt
@@ -1,2 +1,25 @@
 - Explain the order of execution in terms of the event loop for eventloop/immediate.js.
-- Will the order of execution change if timeout is changed to 0? Why or why not?
\ No newline at end of file
+- Will the order of execution change if timeout is changed to 0? Why or why not?
+
+In terms of the event loop, the order of execution for the provided code (`eventloop/immediate.js`) is as follows:
+
+1. `fs.readFile` is called, initiating an asynchronous file read operation.
+2. While waiting for the file read operation to complete, the event loop continues to execute.
+3. Once the file read operation completes, its callback function is added to the task queue.
+4. The event loop picks up the callback function from the task queue and pushes it onto the call stack for execution.
+5. Inside the callback function:
+   - A while loop is executed, artificially delaying the execution for approximately 10 milliseconds.
+   - If there was an error during the file read operation, 'Error' is logged to the console. Otherwise, the data read from the file is logged.
+   - A `setTimeout` callback is scheduled to run after 5 milliseconds.
+   - A `setImmediate` callback is scheduled to run immediately after the current callback function finishes executing.
+6. After the while loop completes and the callback function finishes executing, the call stack becomes empty.
+7. The event loop continues to check for pending tasks. Since both `setTimeout` and `setImmediate` have tasks to execute, they are picked up next.
+
+Now, let's address the question:
+
+- Will the order of execution change if the timeout is changed to 0? Why or why not?
+
+   Yes, changing the timeout to 0 milliseconds will affect the order of execution. 
+   When a timeout is set to 0, it means the callback will be executed as soon as possible, but after the current synchronous code has finished executing and the call stack is empty. 
+   Therefore, in this case, the `setTimeout` callback will be executed immediately after the current callback function finishes executing, potentially before the completion of the while loop inside the callback.
+   However, the `setImmediate` callback will still be scheduled to run immediately after the current callback function finishes executing, ensuring that it runs after the `setTimeout` callback.
\ No newline at end of file
diff --git a/eventloop/quiz/fytd-poll-timer.txt b/eventloop/quiz/fytd-poll-timer.txt
index c5d5128..e771926 100644
--- a/eventloop/quiz/fytd-poll-timer.txt
+++ b/eventloop/quiz/fytd-poll-timer.txt
@@ -1,3 +1,24 @@
 - Explain the order of execution in terms of the event loop for eventloop/poll_timer.js.
 - Will the order of execution change if the delay in the while loop is changed from 10s to 150s? Why or why not?
-- Will the order of execution change if timeout is changed to 0? Why or why not?
\ No newline at end of file
+- Will the order of execution change if timeout is changed to 0? Why or why not?
+
+In terms of the event loop, the order of execution for the provided code (`eventloop/poll_timer.js`) is as follows:
+
+1. The `someAsyncOperation` function is called, initiating an asynchronous file read operation using `fs.readFile`.
+2. `setTimeout` is called with a delay of 100 milliseconds. This schedules a timer event.
+3. The event loop starts executing tasks from the call stack. It executes `someAsyncOperation`, passing a callback function to be executed when the file read operation completes.
+4. While the file read operation is in progress, the event loop continues to execute. However, since the file read operation is asynchronous and non-blocking, it doesn't wait for it to complete.
+5. Once the file read operation completes, its callback function is added to the task queue.
+6. The event loop picks up the callback function from the task queue and pushes it onto the call stack for execution.
+7. Inside the callback function:
+   - 'someAsyncOperation' is logged to the console.
+   - A while loop is executed, which artificially delays execution for approximately 10 milliseconds.
+8. After the while loop completes, the callback function finishes executing, and the call stack becomes empty.
+9. The event loop continues to check for pending tasks. Since the `setTimeout` timer has expired, its callback function is pushed onto the task queue.
+10. The event loop picks up the `setTimeout` callback function from the task queue and pushes it onto the call stack for execution.
+11. Inside the `setTimeout` callback function, the time elapsed since scheduling the timeout is calculated and logged to the console.
+
+
+- No, the order of execution will not change. The delay in the while loop affects only the duration of the artificial delay in the execution of the callback function passed to `someAsyncOperation`. However, since this delay is within the callback function, it doesn't affect the scheduling or execution of other tasks or the `setTimeout` callback.
+
+- Yes, changing the timeout to 0 milliseconds will affect the order of execution. When a timeout is set to 0, it means the callback will be executed as soon as possible, but after the current synchronous code has finished executing and the call stack is empty. Therefore, in this case, the `setTimeout` callback will be executed immediately after the completion of the current synchronous code (including the completion of the while loop inside the `someAsyncOperation` callback), potentially before the completion of the file read operation.
\ No newline at end of file
diff --git a/eventloop/quiz/fytd-poll.txt b/eventloop/quiz/fytd-poll.txt
index 8c861fc..27b11b2 100644
--- a/eventloop/quiz/fytd-poll.txt
+++ b/eventloop/quiz/fytd-poll.txt
@@ -1 +1,27 @@
 - In eventloop/poll.js, what will be the order of execution? Briefly explain the order of execution w.r.t the event loop phases.
+The order of execution for the given code is as follows:
+foo
+done
+Read Error
+1. `someAsyncOperation()` is called.
+2. Inside `someAsyncOperation`, a non-blocking operation `fs.readFile()` is initiated, which reads data from a file asynchronously. This operation is scheduled to run in the background, and the callback function provided to `fs.readFile()` will be executed once the file reading is complete.
+3. `foo()` is called.
+4. Inside `foo()`, 'foo' is logged to the console.
+5. 'done' is logged to the console.
+6. Eventually, the file reading operation initiated by `fs.readFile()` completes. Depending on the file system's speed and the size of the file, this may take some time.
+7. When the file reading operation is complete, its callback function is pushed onto the event queue.
+8. The event loop picks up the callback function from the event queue and pushes it onto the call stack.
+9. Inside the callback function:
+   - If there was an error during the file reading operation, 'Read Error' is logged to the console.
+   - Otherwise, 'Data: ' followed by the contents of the file is logged to the console.
+
+Explanation of the order of execution with respect to the event loop phases:
+
+- When `someAsyncOperation()` is called, it initiates an asynchronous operation (`fs.readFile()`), which is handled by the Node.js runtime and doesn't block the main thread.
+- `foo()` is called immediately after `someAsyncOperation()`.
+- Both `someAsyncOperation()` and `foo()` are synchronous functions, so they are executed one after the other on the main thread.
+- After `foo()` is called, 'done' is logged to the console.
+- Meanwhile, `fs.readFile()` is still running asynchronously in the background.
+- Once `fs.readFile()` completes, its callback function is pushed onto the event queue.
+- The event loop then picks up the callback function and pushes it onto the call stack for execution.
+- This mechanism ensures that even though `fs.readFile()` is asynchronous and doesn't block the main thread, its callback is executed when the operation completes, allowing non-blocking I/O operations in Node.js.
\ No newline at end of file
diff --git a/eventloop/quiz/fytd-timer.txt b/eventloop/quiz/fytd-timer.txt
index 4750c72..6a26d0c 100644
--- a/eventloop/quiz/fytd-timer.txt
+++ b/eventloop/quiz/fytd-timer.txt
@@ -1 +1,25 @@
-- In eventloop/timer.js, what will be the order of execution? Briefly explain the order of execution w.r.t the event loop phases.
\ No newline at end of file
+- In eventloop/timer.js, what will be the order of execution? Briefly explain the order of execution w.r.t the event loop phases.
+
+The order of execution for the given code is as follows:
+
+1. `foo(2)` is called.
+2. Inside `foo` function:
+   - 'foo' is logged to the console.
+   - `setTimeout` is called with a callback function to execute `bar(a)` after a timeout of 0 milliseconds.
+   - `baz()` is called immediately.
+3. 'baz' is logged to the console.
+4. The event loop picks up the callback function from `setTimeout` and executes `bar(a)`.
+5. Inside `bar` function:
+   - `${x} : bar` is logged to the console with the value of `a`.
+6. `foo(1)` is called and the same sequence of steps (2-5) is repeated.
+
+Explanation of the order of execution with respect to the event loop phases:
+
+- When `foo` is called, it gets pushed to the call stack.
+- Inside `foo`, 'foo' is logged, `setTimeout` is called, and `baz()` is executed. Since `setTimeout` has a delay of 0 milliseconds, its callback function is scheduled to be executed after the current execution context finishes and the event loop has a chance to pick it up.
+- After logging 'foo' and calling `baz()`, `foo` finishes executing and is popped off the call stack.
+- The event loop picks up the callback function from `setTimeout` since it's completed its timeout period. The callback function (which logs `bar(a)`) is pushed onto the call stack and executed.
+- Once `bar(a)` finishes executing, it's popped off the call stack.
+- Finally, the event loop picks up the next task, which is the call to `foo(1)`, and the process repeats.
+
+So, the order of execution is 'foo', 'baz', 'bar(2)', 'foo', 'baz', 'bar(1)'.
\ No newline at end of file