[Maszyna RAM] Problemy z algorytmem na palindrom

Witam! Mam podany algorytm, według którego muszę napisać program w Maszynie RAM wypisujący "1", jeżeli podana liczba jest palindromem lub "0" jeżeli nim nie jest. Sęk w tym, że nie rozumiem jak postąpić z punktem "K4 <--- ostatnia cyfra liczby z K3". Chodzi o to żeby wypisać cyfrę jedności?
Algorytm:

chodzi o implemetacje tego :

int Palindrom (int K1)  //gdy palidrom zwroci 0 
{
    int K2,K3,K4;
    
    K2 =0;
    K3 = K1 ;
    while (K3 != 0 )
    {
      K4 =   K3 % 10;  //reszta z dzielenia przez 10 da cyfrę jedności
      K3 = K3 /10 ;    // dzielenie całkowite usunie cyfrę jedności 
      K2 = K2 * 10 + K4;
    }
     if (K1 == K2) return 0  ;else return 1 ;      //pisalem tak choc moza prosciej ale zeby widac bylo
    
}

Jeśli maszyna nie posiada % - zwykła posiada tylko (* , / , + , -)
to % implementujesz dzieleniem całkowitym :

ResztaZDzielenia= Liczba - ( Liczba / 10 ) * 10 ;

Jeżeli aktualne: (w co wątpię :)

 
           read  1                     ###wczytywanie
                       load  =0
                       store 2
                       store 3
                       store 6
                       load  =7
                       store 5
                       load  =1
                       store 4
niewykluczonedwa:      load  1
                       store 2
dawajjeszcze:          jzero koniecobliczen
                       load  3
                       add   =1
                       store 3
                       load  2
                       div   =10
                       store 2
                       jump  dawajjeszcze
koniecobliczen:        load  3
                       div   =2
                       mult  =2
                       sub   3
                       jzero parzyste
                       load  =1
                       store 6
parzyste:              load  3
                       div   =2
                       store 3
potegowaniedziesiatki: load  3
                       jzero koniecpotegdziesiatki
                       sub   =1
                       store 3
                       load  =10
                       mult  4
                       store 4
                       jump  potegowaniedziesiatki
koniecpotegdziesiatki: load  1
                       div   4
                       mult  4
                       store 2
                       load  1
                       sub   2
                       store 2
                       load  1
                       div   4
                       store 1
odwracanietablicy:     load  2                     ###odwracanie tablicy
                       div   4
                       store ^5
                       load  4
                       mult  ^5
                       store 3
                       load  2
                       sub   3
                       store 2
                       load  4
                       div   =10
                       store 4
                       jzero koniecliczbdotablicy
                       load  5
                       add   =1
                       store 5
                       jump  odwracanietablicy
koniecliczbdotablicy:  load  =0                    ###wczytywanie odwrocenia
                       store 2
wczytujdalej:          load  5
                       sub   =7
                       jzero koniecodwracania
                       load  2
                       mult  =10
                       add   ^5
                       store 2
                       load  5
                       sub   =1
                       store 5
                       jump  wczytujdalej
koniecodwracania:      load  6
                       jzero omin
                       load  1
                       div   =10
                       store 1
omin:                  load  1
                       sub   2
                       jzero palindrom
niepalindrom:          write =0
                       halt  
palindrom:             write =1
                       halt