Condicion para evitar "overflows"
=================================

  En la subrutina Multiplicar de la versión en Fortran, la operacion

    lc(ic)=kp+i*lc(ic)

  donde el arrastre kp se ha obtenido en la iteracion anterior como

    lc(ic-1)=kp+i*lc(ic-1)
    kp=lc(ic-1)/nbase
    lc(ic-1)=lc(ic-1)-kp*nbase

  puede dar lugar a un "overflow" si kp, i y lc(ic) tienen valores suficientemente grandes.

  El "overflow" se producira cuando

    kp+i*lc(ic) > INT_MAX

  El caso mas desfavorable se produce cuando

    kp     = INT_MAX/nbase (en la iteracion anterior)
    i      = n             (valor mas alto de i)
    lc(ic) = nbase-1       (cifra de valor mas alto en base nbase)

  Por tanto el "overflow" es posible cuando

    INT_MAX/nbase + n*(nbase-1) > INT_MAX

  lo que equivale a

    n*(nbase-1) > INT_MAX*(1-1/nbase) = INT_MAX*(nbase-1)/nbase

  o, lo que es lo mismo,

    n*nbase > INT_MAX.

  Luego la condicion para que no se produzcan overflows se puede escribir en la forma

    n*nbase < INT_MAX+1 = 2^31




Condicion para que se pueda almacenar el resultado
==================================================

  El numero más grande que se puede representar con nc cifras en base nbase es

     lc(nc)    lc(nc-1)       lc(2)     lc(1)
    (nbase-1) (nbase-1) ... (nbase-1) (nbase-1)

  cuyo valor es

    SUMA  [ (nbase-1) * nbase^(ic-1) ] = (nbase-1) * (1-nbase^(nc-1)*nbase) / (1-nbase)
   ic=1,nc

                                       = nbase^nc - 1

  Luego la condicion para que se pueda almacenar el resultado se puede escribir en la forma

    n! < nbase^nc