Choose a Programming Language: Decide whether you will analyse the Python or

$C++$ version of the program.

Identify Key Instructions: Break down the program into key instructions, focusing

on the following:

Function calls

Variable assignments

Arithmetic operations

Input$/$Qutput operations

Simulate the Fetch$-$Decode$-$Execute Cycle: For each instruction identified, simulate

the fetch$-$decode$-$execute cycle by detailing the following:

Fetch: Describe how the instruction is fetched from memory, including how

the program counter $($ PC $)$ might change.

Decode: Explain what happens during the decoding phase. Identify the

operation to be performed, any operands involved, and how variables are

represented in memory.

Execute: Describe how the CPU executes the instruction, including any

changes to registers or memory locations.

Example Breakdown for $C++($as an example$)$:

Instruction: int sum result $=$ add numbers$($num$1,$ num$2)$;

Fetch: The instruction is fetched from memory. The program counter $($PC$)$

points to the address of this instruction.

Decode: The CPU decodes the instruction, identifying that it needs to call the

add numbers function with num$1$ and num$2$ as arguments. It determines the

memory addresses for these variables.

Execute: The function is called, which adds the values of num$1$ and num$2,$

stores the result in sum result, and the control returns to the next instruction

in the main function.

Discussion Questions:

How do function calls impact the fetch$-$decode$-$execute cycle?

What differences did you notice between the execution of arithmetic operations and

input$/$output operations?

How would the fetch$-$decode$-$execute cycle differ for more complex control structures

like loops or conditionals?