Consider three processes P1, P2, and P3 running identical code, as shown in the pseudocode below. A and B are two binary semaphores initialized to 1 and 0, respectively. X is a shared variable initialized to 0. Each line in the pseudocode is executed atomically. Pseudocode of P1, P2, and P3Wait(A); Print(*); X = X+1; If (X == 2) { Print($); Signal(B); } Signal(A); Wait(B); Print(#); Signal(B);Assume that any of the three processes can start to execute first and context switching can happen between these processes at any arbitrary time and in any arbitrary order. Which of the following patterns is/are possible to be generated as an outcome of the execution of these three processes?

Let us trace the execution of the three processes:

1. First Process (e.g., P1):

   • Executes Wait(A) ($A$ becomes 0).

   • Prints * (output: *).

   • Increments $X$ to 1 ($X = 1$).

   • Condition $X == 2$ is false.

   • Executes Signal(A) ($A$ becomes 1).

   • Executes Wait(B): Since $B = 0$, P1 blocks.

2. Second Process (e.g., P2):

   • Executes Wait(A) ($A$ becomes 0).

   • Prints * (output: **).

   • Increments $X$ to 2 ($X = 2$).

   • Condition $X == 2$ is true, so it executes inside the block:

     • Prints $ (output: **$).

     • Executes Signal(B) ($B$ becomes 1, unblocking a waiting process).

   • Executes Signal(A) ($A$ becomes 1).

3. Remaining Executions:

   • Mutual exclusion on the first block is enforced by semaphore $A$. Because the second process prints $ before releasing $A$, the third process cannot enter to print the third * before $ is printed. Thus, the prefix `*$` is impossible (ruling out option D**).

   • At this point, the prefix is **$, $A = 1$, and $B = 1$.

   • Option A (`$*###):** The third process (P3) executes its first part immediately after P2 releases $A$, printing * before any # is printed. Then all three processes execute Print(#). This yields **$*###`.

   • Option B (`$#*##):** One blocked process (P1 or P2) executes Wait(B), prints #, and signals $B$. Next, P3 executes its first block and prints *. Finally, the remaining two processes print #. This yields **$#*##`.

   • Option C (`$##*#):** Both P1 and P2 complete their execution and each prints #. Then P3 executes, prints *, and proceeds to print #. This yields **$##*#`.

Hence, patterns (A), (B), and (C) are possible.