PROG SEGMENT CODE                               ; definicja segmentu dla programu glownego
PROC SEGMENT CODE                               ; definicja segmentu dla podprogramow
IleLiczb EQU 16

CSEG AT 0
    LJMP start


RSEG PROG
    start:
        ACALL copyROMtoRAM                      ; kopiowanie danych tablicy poczatkowej z pamieci ROM do RAM
        ACALL fibonacci
        SJMP $                                  ; pozostan tu po wykonaniu programu

RSEG PROC
    copyROMtoRAM:
        MOV DPTR, #startowe_liczby              ; wczytanie wskaznika do pamieci ROM
        MOV R0, #40h                            ; wczytanie wskaznika do pamieci RAM (zapisujemy w rejestrze 0, bank 0)
            LOOP:                               ; petla idaca po tablicy
                CLR A                           ; A = 0
                MOVC A, @A + DPTR               ; przeniesienie bajta z pamieci ROM do akumulatora
                JZ EXIT                         ; jezeli natrafilismy na NULL (wartosc 0) wyjdz z petli
                MOV @R0, A                      ; zapisanie wartosci do pamieci RAM
                INC DPTR                        ; zwiekszenie wskaznika na ROM o 1
                INC R0                          ; zwiekszenie wskaznika na RAM o 1
                SJMP LOOP                       ; petla
            EXIT:
                RET                             ; wyjscie z funkcji
    fibonacci:
        MOV R0, #40h                            ; wczytanie wskaznika do pamieci RAM
        MOV R2, #40h                            ; Rejestr 2 bedzie przechowywal adres poczatku naszej tablicy
        MOV R3, #0h                             ; Rejestr 3 bedzie przechowywal nasza pozycje w tablicy (i)
        MOV DPTR, #k                            ; wczytanie wskaznika do pamieci ROM
        MOVC A, @A + DPTR
        MOV R6, A                               ; Bedzie przechowywalo ilosc naszych liczb (k)
        MOV A,#IleLiczb
        MOV R7, A                               ; Wartosc rejestru 7 bedzie zmniejszana na koncu petli az do 0, ilosc generowanych liczb
            PETLA:
                MOV DPTR, #j
                CLR A                           ; Wczytanie
                MOVC A, @A + DPTR               ; wartosci j do
                MOV R1, A                       ; rejestru 1

                MOV A, R6                       ; Wyznaczenie liczby
                ADD A, R3                       ; (k + i)
                SUBB A, R1                      ; Regulka [k + i - j]
                MOV R5, A                       ; Przeniesienie tej wartosci do rejestru 5

                MOV A, R6                       ; Wczytanie naszego k
                MOV B, A                        ; Przeniesienei go do B (mianownik)
                MOV A, R5                       ; Wczytanie naszego indeksu [k+i-j]
                DIV AB                          ; Podzielenie tego przez nasze k
                MOV R4, B                       ; Przeniesienie naszego wlasciwego indeksu do rejestru 4 (R4=[k+i-j] mod k)

                CLR A                           ; Znajdywanie indeksu na ktorym jestesmy
                MOV A, R2                       ; Przypisanie adresu poczatku tablicy
                ADD A, R3                       ; Dodanie naszego i do adresu poczatku tablicy
                MOV R1, A                       ; Przeniesienie tej wartosci do rejestru 1 (R1=adres i-tego elementu)
                MOV A, @R1                      ; Zwrocenie naszej wartosci pod indeksem x[i] do akumulatora
                MOV R5, A                       ; Przeniesienie naszej dobre wartosci do rejestru 5 (R5=x[i])

                CLR A
                MOV A, R2                       ; Wczytanie adresu poczatku tablicy
                ADD A, R4                       ; wlasciwego indeksu do tablicy
                MOV R1, A                       ; Przeniesienei adresu do rejestru 1
                MOV A, @R1                      ; Zwrocenie wartosci pod rejestrem
                ADD A, R5                       ; Otrzymanie wyniku (x[(k + i - j) mod k] + x[i])
                MOV R1, A                       ; Przeniesienie tej wartosci do rejestru 1

                CLR A
                MOV DPTR, #m                    ; Wczytanie wskaznika ROM
                MOVC A, @A + DPTR               ; Wczytanie wartosci m do akuulatora
                MOV B, A                        ; Przepisanie tej wartosci do B

                MOV A, R1                       ; Przepisanie wartosci z rejestru 1 do A
                DIV AB                          ; Operacja (x[(k + i - j) mod k] + x[i]) mod m
                MOV R1, B                       ; Przeniesienie naszego wyniku do rejestru 1

                MOV A, R2                       ; Wczytanie adresu poczatku tablicy
                ADD A, R3                       ; i ustalenie naszego indeksu
                MOV R0, A                       ; Przepisanie tego indeksu do R0 (R0=adres i-tego elementu w pamieci RAM)
                MOV A, R1                       ; Wczytanie naszego wyniku do A
                MOV @R0, A                      ; Nadpisanie tablicy naszym wynikiem

                MOV A,R3                        ;Wyliczenie nowego i
                ADD A,#1h
                MOV B,R6;
                DIV AB
                MOV R3,B                        ;i=(i+1) mod k

                DJNZ R7, PETLA
            WYJSCIE:
                RET

CSEG AT 250h
    startowe_liczby:
        DB 4, 5, 3, 3, 3, 4, 6, 2, 6, 5, 0
    j:
        DB 7
    k:
        DB 10
    m:
        DB 4

END