C/C++ - Big Number

Ciao a tutti! In questi giorni stavo cercando di realizzare un programma che codificasse dei messaggi con la crittatura RSA e mi sono inbattuto nel programma BigNumber. Ho notato che non esegue bene le differenze (ed infatti il creatore lo aveva scritto nel source) ed ho provato a scrivere io l'algoritmo... Non so se è il posto giusto per postarlo.

P.S. sono alle prime armi con la programmazione quindi è inevitabile che si può migliorare di molto il codice da me scritto, però direi che funziona anche con numeri molto grandi

#include <stdio.h>
#include <stdlib.h>
#include <BigNumber.h>

int main(int argc, char *argv[])
{
    LUN_BNUM=100;
    
    BigN n,l;
    
    n=bIntero();
    l=bIntero();
    
    bLeggi(n);
    bLeggi(l);


    int i,c,lris,p;
    if (n->lun==l->lun) {           //calcola il numero di cifre che avrà il risultato
                        i=n->lun;
                        while (n->pun[i]==l->pun[i] && i>1) {
                              i--;
                              }
                        if (n->pun[i]-l->pun[i]==1 && n->pun[i-1]<l->pun[i-1]) {
                                                    i--;
                                                    }
                        while (n->pun[i]==0 && l->pun[i]==9) {
                              i--;
                              }
                        if (i==0) {
                                  i=1;
                                  }
                        lris=i;
                                                    }
                                                         
    if (n->lun > l->lun) {
                       c=n->lun;
                       if (n->lun - l->lun==1 && n->pun[c]==1 && n->pun[c-1]<l->pun[c-1]) {
                                            c--;
                                            }
                           while (n->pun[c]==0 && l->pun[c]==9) {
                                 c--;
                                 }
                       if (n->lun - l->lun > 1) {
                                  p=l->lun;
                                           if (n->pun[p] < l->pun[p] && n->pun[p]==0) {
                                                         while (n->pun[p]==0) {
                                                               p++;
                                                               }
                                                               }
                                           if (p==c && n->pun[c]==1) {
                                                    c--;
                                                    }
                                  if(n->pun[c]==0) {
                                                   c--;
                                                   }
                                  }
                       if (c==0) {
                                 c=1;
                                 }
                       lris=c;
                       }
                       
    BigN ris;
    int z=1,d;
    ris=bIntero();
        while (z<=lris) {                    //esegue la sottrazione
              if (n->pun[z] < l->pun[z]) {
                 ris->pun[z] = 10+(n->pun[z]) - l->pun[z];
                             if (n->pun[z+1] != 0) {
                                             n->pun[z+1] = n->pun[z+1] - 1;
                                             }
                             else
                             {
                                 n->pun[z+1] = 9;
                                 d=z+2;
                                       while (n->pun[d]==0) {
                                             n->pun[d]=9;
                                             d++;
                                             }
                                 n->pun[d] = n->pun[d] - 1;
                             }
                            z++;
                            }
              else
              {
                  ris->pun[z] = n->pun[z] - l->pun[z];
                  z++;
                  }   
                  }
                                  
 while (lris > 0){
    printf ("%d", ris->pun[lris]);
    lris--;
   }


  printf("\n");
  
  system("PAUSE");	
  return 0;
}