You are to design, write, assemble, and simulate an assembly language program which will generate Fibonacci sequence numbers. Giving is a table NARR of byte-long numbers (with a $00 sentinel). Each element in the table corresponds to the sequence number of a Fibonacci number to be generated. The actual calculation of the corresponding 4-byte Fibonacci numbers has to be implemented in a subroutine. The 4-byte Fibonacci numbers have to be passed back to the main program, which stores them in the RESARR array.

(please do write with Motorola 68HC11 microcontroller and please do fit the contents in the template)

Requirement is below:

1. Your program should work for any N value, not just the ones given in the table.

2. Do NOT use the X or Y registers for storing or manipulating DATA. Only use the X and Y registers for storing/manipulating ADDRESSES.

3. All multi-byte data items are in Big Endian format (including all program variables)

4. Your program is NOT allowed to change the numbers stored in the NARR table.

5. You have to use the program skeleton provided for Lab4. Do not change the data section or you will lose points! This means: do not change the 'ORG $B000' and 'ORG $B010' statements or the variable names NARR and RESARR. Do NOT change the values assigned to the NARR table. If you need to define additional variables, please add them in the appropriate places.

6. You are allowed to declare static variables in your subroutine (through RMB).

7. Your subroutine does not have to be transparent. This means that your subroutine does not have to restore the original content of registers (the content of registers when entering the subroutine) before exiting the subroutine.

8. Your subroutine should only have one exit point. This means that only a single RTS instruction at the end of the subroutine is allowed.

9. Initialize any additional variables that your program (main program and subroutine) needs within the program, NOT with a FCB or FDB in the data section

10. You must terminate your main program correctly using an infinite loop structure.

11. You do not have to optimize your algorithm or your assembly program for speed.

12. You have to provide a pseudo-code solution for your main program AND your subroutine. In your pseudo code, do NOT use a for loop, but either a while or a do-until construct to implement a loop. Also, do NOT use any goto, break, or exit statements in your pseudocode.

13. The structure of your assembly program should match the structure of your pseudo code 1-to-1.

14. The main program should be a WHILE structure which goes through the NARR table and sends an N value to the subroutine during each iteration. The while structure will also check for the Sentinel (which is the $00 at the end of the table) at each iteration. The Sentinel is NOT one of the data items and it should NOT be processed by the subroutine. The main program must end the while loop when the $00 is encountered. For each subroutine call, the subroutine will send back a 4-byte result that has to be stored consecutively in the RESARR array in Big-Endian format.

- You are not allowed to just manually count the number of elements in the table and set up a fixed number in memory as a count variable.

- Your program should still work if the arrays (NARR and RESARR) are moved to different places in memory (do not use any fixed offsets).

- You dont have to copy the sentinel to the end of the RESARR array.

- Your program should work for any number of elements in the table. Thus, there could be more than 255 elements in the table. Using the B-register as an offset and the ABX/ABY instructions to point into the array will therefore not work.

15. For each iteration, the main program should take one number from the NARR table and pass it to the subroutine in a REGISTER (call-by-value in register). The subroutine performs the calculation and produces the corresponding 4-byte Fibonacci number. The resulting 4-byte number must be passed back to the main program OVER THE STACK (call-by-value over the stack) in Big Endian format. The main program then retrieves the 4 bytes from the stack and stores them in the RESARR array in Big Endian format. Thus, if the NARR table has 8 data items (excluding the sentinel), the RESARR array should consist of 32 bytes (8 4- byte Fibonacci numbers) after program execution.

- ALL of the number processing must be done inside a single subroutine.

- Make sure that your program will not generate a stack underflow or overflow.

16. You do not have to check for overflow when calculating the Fibonacci numbers.

17. Any assembler or simulator error/warning messages appearing when assembling/simulating your submitted program will result in 50 points lost.

The Template is blow:

* Program description:

*

* Pseudocode of Main Program:

*

*---------------------------------------

*

* Pseudocode of Subroutine:

*

**************************************

* start of data section

ORG $B000

NARR FCB 1, 2, 5, 10, 20, 128, 254, 255, $00

SENTIN EQU $00

ORG $B010

RESARR RMB 32

* define any variables that your MAIN program might need here

* REMEMBER: Your subroutine must not access any of the main

* program variables including NARR and RESARR.

ORG $C000

LDS #$01FF initialize stack pointer

* start of your main program

* define any variables that your SUBROUTINE might need here

ORG $D000

* start of your subroutine