Consider the C functions foo and bar given below:int foo(int val) { int x = 0; while(val > 0) { x = x + foo(val--); } return val; } int bar(int val) { int x = 0; while(val > 0) { x = x + bar(val-1); } return val; }Invocations of foo (3) and bar (3) will result in :

Let us analyze the behavior of both functions:

1. For foo(3):

   • When foo(3) is called, val = 3 > 0 is true.

   • Inside the loop, it evaluates foo(val--). The postfix decrement val-- evaluates to $3$ as the argument to the recursive call, before decrementing val.

   • Therefore, foo(3) immediately calls foo(3) again.

   • This causes an infinite sequence of recursive calls with the parameter $3$, consuming stack frames continuously until memory runs out.

   • This results in a stack overflow, leading to abnormal termination (crash).

2. For bar(3):

   • When bar(3) is called, it enters while(val > 0) and calls bar(2), which in turn calls bar(1).

   • Inside bar(1):

     • The loop condition val > 0 ($1 > 0$) is true.

     • It calls bar(0).

     • Inside bar(0), val = 0, so the loop while(val > 0) is skipped and bar(0) immediately returns $0$.

     • Control returns to bar(1), where x = x + 0 is executed.

     • In bar(1), the value of val is still $1$ because val - 1 was passed by value and val itself was never modified.

     • The loop in bar(1) continues with val = 1 > 0 and calls bar(0) repeatedly in an infinite loop without causing a stack overflow (as bar(0) returns immediately each time).

Hence, foo(3) results in abnormal termination, and bar(3) results in an infinite loop.

Thus, option (C) is the correct answer.