www.pudn.com > calc.rar > fun.h

#ifndef __FUN_H__ 
#define __FUN_H__ 
 
#define dprintd(expr) printf(#expr " = %d\n", expr); fflush(stdout) 
#define dprintld(expr) printf(#expr " = %ld\n", expr); fflush(stdou)t 
#define dprintg(expr) printf(#expr " = %g\n", expr); fflush(stdout) 
#define dprints(expr) printf(#expr " = %s\n", expr); fflush(stdout) 
#define dprintc(expr) printf(#expr " = %c\n", expr); fflush(stdout) 
#define dprintu(expr) printf(#expr " = %u\n", expr); fflush(stdout) 
#define dprintlu(expr) printf(#expr " = %lu\n", expr); fflush(stdout) 
 
#define DPRINTPI(expr) printf(#expr " = "); PRINTPI(expr); printf("\n");\ 
 fflush(stdout) 
#define DPRINTI(expr) printf(#expr " = "); PRINTI(expr); printf("\n"); \ 
fflush(stdout) 
#define DPRINTR(expr) printf(#expr " = "); PRINTR(expr); printf("\n"); \ 
fflush(stdout) 
 
 
 
#include "pI.h" 
#include "roots.h" 
#include "wrappers.h" 
extern long nettbytes; 
int isatty(int fd); 
FILE *Fopen_r(char *filename); 
MPI *ZSUB2IPLUS1(MPI *X, MPI *R, MPI *S, MPI *U, MPI *V, MPI *N); 
MPI *XSUB2IPLUS1(MPI *X, MPI *Z, MPI *R, MPI *S, MPI *U, MPI *V, MPI *P, MPI *Q, MPI *N); 
MPI *ZSUB2I(MPI *R, MPI *S, MPI *P, MPI *Q, MPI *N); 
MPI *XSUB2I(MPI *R, MPI *S, MPI *P, MPI *Q, MPI *N); 
MPI *FIBONACCI(USI n); 
MPI *FUND_UNIT(MPI *D, MPI **Xptr, MPI **Yptr); 
MPI *FUND_UNITX(MPI *D, MPI **Xptr, MPI **Yptr); 
MPI *PEL(MPI *D, MPI *E, MPI **Xptr, MPI **Yptr); 
MPI *PELX(MPI *D, MPI *E, MPI **Xptr, MPI **Yptr); 
MPI *JUGGLERT(MPI *Dptr); 
MPI **SMITHI(MPMATI *Mptr, MPMATI **Pptr, MPMATI **Qptr, USI *ptr, MPI *Eptr, USI m1, USI n1); 
MPI **SMITHI1(MPMATI *Mptr, USI *ptr, MPI *Eptr, USI m1, USI n1); 
MPI *ABSI(MPI *Aptr); 
MPI *ADD0I(MPI *Aptr, MPI *Bptr); 
MPI *ADD0_I(MPI *Aptr, unsigned long b); 
MPI *ADDI(MPI *Aptr, MPI *Bptr); 
MPI *ADDM(MPI *Aptr, MPI *Bptr, MPI *Mptr); 
MPI *APPROXN(MPI *Aptr, unsigned int m); 
MPI *BABY_DIVIDE(MPI *Nptr); 
MPI *BABY_MTHROOT(MPI *Aptr, unsigned int m); 
MPI *BANK_REALLOC(MPI *Aptr, unsigned int degree); 
MPI *BIG_FACTOR(MPI *Nptr); 
MPI *BIG_MTHROOT(MPI *Aptr, unsigned int m); 
MPI *BIG_MTHROOTX(MPI *Aptr, MPI *M); 
MPI *BINOMIAL(USI n, USI m); 
MPI *BRENT_POLLARD(MPI *Nptr); 
MPI *BUILDMPI(unsigned int n); 
MPI *CHANGE(unsigned long n); 
MPI *CHANGEI(long n); 
MPI *CHINESE(MPI *A, MPI *B, MPI *M, MPI *N, MPI **Mptr); 
MPI *CHINESEX(MPI *A, MPI *B, MPI *M, MPI *N, MPI **Mptr); 
MPI *CHINESE_ARRAY(MPI *A[], MPI *M[], MPI **Mptr, USI n); 
MPI *CHINESE_ARRAYX(MPIA A, MPIA M, MPI **Mptr); 
MPI *COLLATZT(MPI *Dptr); 
MPI *COLSUMI(MPMATI *Mptr, USI j); 
MPI *CONGR(MPI *A, MPI *B, MPI *M, MPI **N); 
MPI *CONGRX(MPI *A, MPI *B, MPI *M, MPI **N); 
MPI *COPYI(MPI *Aptr); 
MPI *CRA(USL n, USL *a, USL *m); 
MPI *DIVISOR(MPI *N); 
MPI *DIVISORX(MPI *N); 
MPI *DIVM(MPI *Aptr, MPI *Bptr, MPI *Mptr); 
MPI *DOTRI(MPMATI *Mptr, USI i, USI j); 
MPI *EUCLIDI(MPI *Pptr, MPI *Qptr, MPI **Hptr, MPI **Kptr); 
MPI *EULER(MPI *N); 
MPI *EULERX(MPI *N); 
MPI *FACTORQ(); 
MPI *FACTORQ1(MPI *Q, USI factored, USL base[], USL **M1, USI FBASE, long x, USL r1[], USL r2[], USL r, int INDEX[], USI CTR[]); 
MPI *FACTORX(MPI *N); 
MPI *FFM(MPI *a, MPI *b, USL K); 
MPI *FINPUTI(FILE *f, unsigned int *uptr); 
MPI *GCD(MPI *Aptr, MPI *Bptr); 
MPI *GCD_ARRAY(MPIA M); 
MPI *GCD_ARRAYV(MPIA M, MPIA *Y); 
MPI *GCD_ARRAYVX(MPIA M, MPIA *Y); 
MPI *INPUTI(unsigned int *uptr); 
MPI *INPUTSI(char **ptr, unsigned int *uptr); 
MPI *INPUTSID(char **ptr, unsigned int *uptr); 
MPI *INT(MPI *Aptr, MPI *Bptr); 
MPI *INT0(MPI *Aptr, MPI *Bptr); 
MPI *INT0_(MPI *Aptr, unsigned long b); 
MPI *INTI(MPI *Aptr, MPI *Bptr); 
MPI *INT_(MPI *Aptr, unsigned long b); 
MPI *INVERSEM(MPI *Nptr, MPI *Mptr); 
MPI *INVERSEMX(MPI *A, MPI *M); 
MPI *JACOB(MPI *M, MPI *N); 
MPI *LCM(MPI *Aptr, MPI *Bptr); 
MPI *LCM_ARRAY(MPIA M); 
MPI *LENGTHX(MPI *N); 
MPI *LENGTHSQCI(MPMATI *Mptr, USI i); 
MPI *LENGTHSQRI(MPMATI *Mptr, USI j); 
MPI *LPRIMROOT(MPI *P); 
MPI *LPRIMROOTX(MPI *P); 
MPI *LUCAS(MPI *N); 
MPI *LUCASB(MPI *N); 
MPI *LUCASS(USI n); 
MPI *LUCASBX(MPI *N); 
MPI *LUCASU(MPI *N, MPI *Q, MPI *M); 
MPI *LUCASUX(MPI *N, MPI *Q, MPI *M); 
MPI *LUCASX(MPI *N); 
MPI *MAXELTI(MPMATI *Mptr); 
MPI *MINELTI(MPMATI *Mptr); 
MPI *MINUSI(MPI *Aptr); 
MPI *MINUSM(MPI *Aptr, MPI *Mptr); 
MPI *MINUS_ONEI(); 
MPI *MOBIUS(MPI *N); 
MPI *MOBIUSX(MPI *N); 
MPI *MOD(MPI *Aptr, MPI *Bptr); 
MPI *MOD0(MPI *Aptr, MPI *Bptr); 
MPI *MPOWER(MPI *Aptr, MPI *Bptr, MPI *Cptr); 
MPI *MPOWERX(MPI *Aptr, MPI *Bptr, MPI *Cptr); 
MPI *MPOWER_(long a, MPI *Bptr, MPI *Cptr); 
MPI *MPOWER_M(MPI *Aptr, USL b, MPI *Cptr); 
MPI *MPQS1(MPI *N); 
MPI *MULT32X(MPI *X, MPI *Y); 
MPI *MULTABC(MPI *A, MPI *B, MPI *C); 
MPI *MULTI(MPI *Aptr, MPI *Bptr); 
MPI *MULTI3(MPI *A, MPI *B, MPI *C); 
MPI *MULTM(MPI *Aptr, MPI *Bptr, MPI *Mptr); 
MPI *MULT_I(MPI *Aptr, long b); 
MPI *MULT_II(MPI *Aptr, USL b); 
MPI *NEAREST_INTI(MPI *Aptr, MPI *Bptr); 
MPI *NEAREST_INTR(MPR *Aptr); 
MPI *NEWTON(MPI *Aptr, unsigned int m, MPI *Fptr); 
MPI *NEXT_PRIME(MPI *M, USI *hptr); 
MPI *NEXT_PRIMEX(MPI *M); 
MPI *NEXTPRIMEAP(MPI *A, MPI *B, MPI *M); 
MPI *NEXTPRIMEAPX(MPI *A, MPI *B, MPI *M); 
MPI *Nextprime(MPI *N); 
MPI *ONEI(); 
MPI *ORDERM(MPI *A, MPI *M); 
MPI *ORDERMX(MPI *A, MPI *M); 
MPI *ORDERP(MPI *A, MPI *P); 
MPI *ORDERPX(MPI *A, MPI *P); 
MPI *ORDERQ(MPI *A, MPI *P, unsigned int n); 
MPI *ORDERQX(MPI *A, MPI *P, MPI *N); 
MPI *PI(unsigned int r); 
MPI *PINCH_PRIME(MPI *M, MPI *N, long *base, USI FBASE, USI *hptr); 
MPI *POLLARD(MPI *Nptr); 
MPI *POWERI(MPI *Aptr, unsigned n); 
MPI *POWER_I(long a, unsigned n); 
MPI *PROB_PRIME(MPI *M, MPI *N, USI *hptr); 
void Parse(); 
MPI *ROWSUMI(MPMATI *Mptr, USI i); 
MPI *RSAE(MPI *Pptr, MPI *Qptr); 
MPI *RSAEX(MPI *Pptr, MPI *Qptr); 
MPI *SHIFTLB(MPI *U); 
MPI *SIGMA(MPI *N); 
MPI *SIGMAX(MPI *N); 
MPI *SQRTM(MPI *x, MPI *p); 
MPI *SQRTMX(MPI *x, MPI *p); 
MPI *SUB0I(MPI *Aptr, MPI *Bptr); 
MPI *SUB0_I(MPI *Aptr, unsigned long b); 
MPI *SUBI(MPI *Aptr, MPI *Bptr); 
MPI *SUBM(MPI *Aptr, MPI *Bptr, MPI *Mptr); 
MPI *TWOI(); 
MPI *UPDATEMAXI(MPI *S, MPMATI *Mptr); 
MPI *ZEROI(); 
MPMATI *ADDMATI(MPMATI *Mptr, MPMATI *Nptr); 
MPMATI *ADD_MULT_ROWI(USI p, USI q, MPI *Aptr, MPMATI *Mptr); 
MPMATI *BASIS_REDUCTION(MPMATI *Bptr, MPMATI **Eptr, USI rowstage, USI m1, USI n1); 
MPMATI *BASIS_REDUCTION0(MPMATI *Bptr, USI m1, USI n1); 
MPMATI *BASIS_REDUCTION00(MPMATI *Bptr, USI m1, USI n1, USI norig); 
MPMATI *BUILDMATI(unsigned int m, unsigned int n); 
MPMATI *COLSUBI(USI p, USI q, MPI *Aptr, MPMATI *Mptr); 
MPMATI *COLSUBI0(USI p, USI q, MPI *Aptr, MPMATI *Mptr); 
MPMATI *COPYMATI(MPMATI *Mptr); 
MPMATI *DELETE_COL1I(MPMATI *Mptr); 
MPMATI *DELETE_ROW1I(MPMATI *Mptr); 
MPMATI *DELETE_ROWI(USI r, MPMATI *Mptr); 
MPMATI *EXTGCD(MPMATI *Dptr, MPI **Aptr, MPMATI **Q, USI m1, USI n1); 
MPMATI *FINPUTMATFILEI_I(); 
MPMATI *FINPUTMATI(FILE *infile); 
MPMATI *HERMITE1(MPMATI *Aptr, USI *T, USI nz); 
MPMATI *HERMITE1P(MPMATI *Aptr, MPMATI *Pptr, MPMATI **Qptr, USI *T, USI nz); 
MPMATI *IDENTITYI(USI n); 
MPMATI *INPUTMATI(); 
MPMATI *MULTMATI(MPMATI *Mptr, MPMATI *Nptr); 
MPMATI *ROWSUBI(USI p, USI q, MPI *Aptr, MPMATI *Mptr); 
MPMATI *ROWSUBI0(USI p, USI q, MPI *Aptr, MPMATI *Mptr); 
MPMATI *SUBMATI(MPMATI *Mptr, MPMATI *Nptr); 
MPMATI *SWAP_COLSI(USI p, USI q, MPMATI *Mptr); 
MPMATI *SWAP_COLSI1(USI p, USI q, MPMATI *Mptr); 
MPMATI *SWAP_ROWSI(USI p, USI q, MPMATI *Mptr); 
MPMATI *SWAP_ROWSI1(USI p, USI q, MPMATI *Mptr); 
MPMATI *ZEROMNI(USI m, USI n); 
MPMATR *BUILDMATR(USI m, USI n); 
MPMATR *CHOLESKYR(MPMATR *A); 
MPMATR *COPYMATR(MPMATR *Mptr); 
MPMATR *ZEROMNR(USI m, USI n); 
MPR *ADDR(MPR *Aptr, MPR *Bptr); 
MPR *BUILDMPR( ); 
MPR *COPYR(MPR *Aptr); 
MPR *FINPUTR(FILE *f, unsigned int *uptr); 
MPR *FRAC_PARTI(MPI *Aptr, MPI *Bptr); 
MPR *FRAC_PARTR(MPR *Aptr); 
MPR *INPUTR(unsigned int *uptr); 
MPR *INPUTSR(char **ptr, unsigned int *uptr); 
MPR *INPUTSRD(char **ptr); 
MPR *INTR(MPR *Aptr); 
MPR *INTROOT(MPR *Z, MPR *U); 
MPR *INVERSER(MPR *Aptr); 
MPR *MINUSR(MPR *Aptr); 
MPR *MINUS_ONER(); 
MPR *MTHROOTR(MPR *Nptr, unsigned int m, unsigned int r); 
MPR *MULTABCR(MPR *A, MPR *B, MPR *C); 
MPR *MULTR(MPR *Aptr, MPR *Bptr); 
MPR *ONER(); 
MPR *TWOR(); 
MPR *PII(unsigned int r); 
MPR *POWERR(MPR *Aptr, unsigned int n); 
MPR *POWERR_2(MPR *R, int n); 
MPR *RATIOI(MPI *Aptr, MPI *Bptr); 
MPR *RATIOR(MPR *Aptr, MPR *Bptr); 
MPR *RECIPROCAL(unsigned long n); 
MPR *SUBR(MPR *Aptr, MPR *Bptr); 
MPR *ZEROR(); 
char *Fgets(FILE *f); 
char *Gets(); 
int COMPAREI(MPI *Aptr, MPI *Bptr); 
int COMPARER(MPR *Aptr, MPR *Bptr); 
int QSORTCOMPAREI(const void *Aptr, const void *Bptr); 
int QSORTRSV(const void *Aptr, const void *Bptr); 
int GetCharFlush(); 
int JACOBI(USL n, USL m); 
int JACOBIB(MPI *N, MPI *M); 
int MAX(int i, int j); 
int MIN(int i, int j); 
int RSV(MPI *Aptr, MPI *Bptr); 
int execerror(char *s, char *t); 
int scanf01(USI *jptr); 
int scanf011(USI *jptr, USI *kptr); 
int scanf0112(USI *jptr, USI *kptr, USI *lptr, USI *mptr); 
int scanf012(USI *jptr, USI *kptr, USI *lptr); 
int scanf0122(USI *jptr, USI *kptr, USI *lptr, USI *mptr, USI *nptr); 
int scanf01221(USI *jptr, USI *kptr, USI *lptr, USI *mptr, USI *nptr, USI *optr); 
int scanf02(USI *jptr, USI *kptr); 
int scanf021(USI *jptr, USI *kptr, USI *mptr); 
int scanf03(USI *jptr, USI *kptr, USI *lptr); 
int scanf031(USI *jptr, USI *kptr, USI *lptr, USI *mptr); 
int scanf05(USI *iptr, USI *jptr, USI *kptr, USI *lptr, USI *mptr); 
int scanf051(USI *iptr, USI *jptr, USI *kptr, USI *lptr, USI *mptr, USI *nptr); 
int scanf10(USI *jptr); 
int scanf11(USI *jptr, USI *kptr); 
int scanf12(USI *jptr, USI *kptr, USI *lptr); 
int scanf121(USI *hptr, USI *jptr, USI *kptr, USI *mptr); 
int scanf13(USI *iptr, USI *jptr, USI *kptr, USI *lptr); 
int scanf131(USI *iptr, USI *jptr, USI *kptr, USI *lptr, USI *mptr); 
int scanf20(USI *iptr, USI *jptr); 
int scanf21(USI *jptr, USI *kptr, USI *mptr); 
int scanf22(USI *iptr, USI *jptr, USI *kptr, USI *lptr); 
int scanf221(USI *hptr, USI *iptr, USI *jptr, USI *kptr, USI *mptr); 
int scanf23(USI *iptr, USI *jptr, USI *kptr, USI *lptr, USI *mptr); 
int scanf231(USI *iptr, USI *jptr, USI *kptr, USI *lptr, USI *mptr, USI *nptr); 
int scanf30(USI *iptr, USI *jptr, USI *kptr); 
int scanf321(USI *gptr, USI *hptr, USI *iptr, USI *jptr, USI *kptr, USI *mptr); 
int scanf40(USI *iptr, USI *jptr, USI *kptr, USI *lptr); 
int scanfd10(int *jptr); 
int whitespace(FILE *f); 
unsigned int *KB_ROW(MPMATI *Aptr, USI *nz); 
unsigned int *KB_ROWP(MPMATI *Aptr, MPMATI **Pptr, USI *nz); 
unsigned int BINARY(USL i); 
unsigned int BINARYB(MPI *N); 
unsigned int COLSEEKI(USI i, MPMATI *Mptr); 
unsigned int EQMINUSONECI(); 
unsigned int EQMINUSONECR(); 
unsigned int EQMINUSONEI(); 
unsigned int EQMINUSONER(); 
unsigned int EQONECI(); 
unsigned int EQONECR(); 
unsigned int EQONEI(MPI *Mptr); 
unsigned int EQONER(); 
unsigned int EQUALI (MPI *Aptr, MPI *Bptr); 
unsigned int EQUALR(MPR *Aptr, MPR *Bptr); 
unsigned int EQZEROCI(); 
unsigned int EQZEROCR(); 
unsigned int EQZEROI(MPI *Mptr); 
unsigned int EQZEROR(); 
unsigned int FACTOR(MPI *Nptr); 
unsigned int GetYN(); 
unsigned int HAVAS_PIVOTI(MPMATI *Mptr, USI *rptr, USI *cptr, USI r, USI s); 
unsigned int LENGTHm(USL n); 
unsigned int MATSEEKI(USI i, MPMATI *Mptr); 
unsigned int MILLER(MPI *Nptr, USL b); 
unsigned int ORDERECP(MPI *X, MPI *Z, MPI *P, MPI *Q, MPI *N); 
unsigned int PRIME_FACTORS(MPI *Nptr); 
unsigned int Q_PRIME_TEST(MPI *Nptr); 
unsigned int REDUCED(MPI *D, MPI *U, MPI *V, USI i); 
unsigned int ROWSEEKI(USI i, MPMATI *Mptr); 
unsigned int SELFRIDGE(MPI *Nptr, USI *uptr); 
unsigned int STEP4(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPMATI **Eptr, MPI *D[], USI i); 
unsigned int STEP40(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPI *D[]); 
unsigned int STEP400(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPI *D[],USI gcdflag,USI norig); 
unsigned int binary(USL i); 
unsigned long **idim2(USI row, USI col); 
unsigned long *ERATOSTHENES(USI n); 
unsigned long *FFI(USL N, USL *b, USL w, USL p); 
unsigned long *FFP(USL N, USL *a, USL *b, USL m, USL n, USL w, USL p); 
unsigned long *FFT(USL N, USL *a, USL w, USL p); 
unsigned long ADDm(USL a, USL b, USL m); 
unsigned long ADDm(USL a, USL b, USL m); 
unsigned long CONVERTI(MPI *N); 
unsigned long DIVm(USL a, USL b, USL m); 
unsigned long GCDm(USL m, USL n); 
unsigned long INVERSEm(USL n, USL m); 
unsigned long INVERSEm(USL n, USL m); 
unsigned long INVERSEm(USL n, USL m); 
unsigned long LENGTHDR(unsigned int d, MPR *Mptr); 
unsigned long LENGTHI(MPI *Mptr); 
unsigned long LENGTHR(MPR *Mptr); 
unsigned long MINUSm(USL a, USL m); 
unsigned long MINUSm(USL a, USL m); 
unsigned long MOD0_(MPI *Aptr, unsigned long b); 
unsigned long MODINT0_(MPI *Aptr, unsigned long b, MPI **Qptr); 
unsigned long MOD_(MPI *Aptr, unsigned long b); 
unsigned long MULT32(USL x, USL y); 
unsigned long MULTm(USL a, USL b, USL m); 
unsigned long MULTm(USL a, USL b, USL m); 
unsigned long POWER_m(USL a, USL y, USL m); 
unsigned long POWERm(USL a, MPI *Bptr, USL m); 
unsigned long RANDOMm(USL x); 
unsigned long RUSSm(USL a, USL b, USL c, USL p); 
unsigned long RUSSm(USL a, USL b, USL c, USL p); 
unsigned long RUSSm(USL a, USL b, USL c, USL p); 
unsigned long SQRTm(USL x, USL p); 
unsigned long SUBm(USL a, USL b, USL m); 
unsigned long SUBm(USL a, USL b, USL m); 
void *calloc1(size_t m, size_t n); 
void *malloc1(size_t nbytes); 
void *realloc1(void *ptr, size_t nbytes, long mbytes); 
void ADD_CUBICR(MPR *X1, MPR *Y1, MPR *X2, MPR *Y2, MPR **Xptr, MPR **Yptr, MPR *A1, MPR *A2, MPR *A3, MPR *A4, MPR *A6); 
void ADD_CUBICRX(); 
void *ADD_MULT_ROWI0(USI p, USI q, MPI *Aptr, MPMATI *Mptr); 
void BASIS_UPDATE(USI i, USI m, MPMATI **Cptr, MPMATI **Lptr, MPMATI *B1ptr, MPI *D[]); 
void COLLATZ(MPI *Dptr, MPI *Eptr); 
void CONT_FRAC(MPI *Aptr, MPI *Bptr, MPI *Zptr, MPI **Xptr, MPI **Yptr); 
void CSWAP_UPDATE(USI k, USI m, MPI *S, MPMATI **Cptr, MPI *D[]); 
void DECODE(MPI *Dptr, MPI *Rptr); 
void DECODEX(MPI *Eptr, MPI *Pptr, MPI *Qptr); 
void DUMPMPI(MPI *Mptr, char *name); 
void EXZPOWER(MPI *X, MPI *Z, USI k, MPI *P, MPI *Q, MPI **Aptr, MPI **Cptr, MPI *N); 
void ADD_ELLIPTIC_Q(MPR *X1, MPR *Y1, MPR *X2, MPR *Y2, MPR **Xptr, MPR **Yptr, MPR *A, MPR *B); 
void ENCODE(MPI *Eptr, MPI *Rptr); 
void EXP_UPDATE(MPI *Q, USL base[], USI FBASE, USI exponents[]); 
void EXTGCDX(); 
void FFlush(FILE *f); 
void FIB_MIN(); 
void FINCKE_POHSTX(); 
void FREEMATR(MPMATR *Mptr); 
void FINCKE_POHST(MPMATR *Q, MPR *C, USI filename); 
void FIND(unsigned int k, MPI *A1ptr, MPI *B1ptr, unsigned long R[]); 
void FPRINTDR(FILE *outfile, unsigned int d, MPR *Mptr); 
void FPRINTI(FILE *outfile, MPI *Mptr); 
void FPRINTMATI(FILE *outfile, USI i1, USI i2, USI j1, USI j2, MPMATI *Mptr); 
void FPRINTMATR(FILE *outfile, USI i1, USI i2, USI j1, USI j2, MPMATR *Mptr); 
void FPRINTR(FILE *outfile, MPR *Aptr); 
void FREEMATI(MPMATI *Mptr); 
void FREEMPI(MPI *Mptr); 
void FREEMPIBANK(); 
void FREEMPR(MPR *Mptr); 
void Flush(); 
void GetReturn(); 
void HERMITE(); 
void IMPROVEPX(); 
void INITMPIBANK(); 
void INTSETI(int *Aptr, unsigned long n, int m); 
void INTSETL(long *Aptr, unsigned long n, long m); 
void INTSETUI(unsigned int *Aptr, unsigned long n, unsigned int m); 
void INTSETUL(unsigned long *Aptr, unsigned long n, unsigned long m); 
void JUGGLER(MPI *Dptr, MPI *Iptr); 
void LUCAS_MIN(); 
void MAXELTI1(MPMATI *Mptr, USI *iptr, USI *jptr); 
void MILLERX(MPI *N, MPI *B); 
void MINELTI1(MPMATI *Mptr, USI *iptr, USI *jptr); 
void MLLL(); 
void MTHROOT(MPI *Aptr, MPI *Bptr, unsigned int m, unsigned int r); 
void MTHROOTX(MPI *Aptr, MPI *Bptr, MPI *M, MPI *R); 
MPR *MULTR3(MPR *A, MPR *B, MPR *C); 
void MULTXM(MPI *a, MPI *b, MPI *c, MPI *d, MPI **eptr, MPI **fptr, MPI *x, MPI *p); 
void MULTXm(USL a, USL b, USL c, USL d, USL *eptr, USL *fptr, USL x, USL p); 
void NEXT(int k, MPI *A1ptr, MPI *B1ptr, unsigned long R[]); 
void PELL(MPI *Dptr, MPI *Eptr); 
void POWER_CUBICRX(); 
void POWER_CUBICR(MPR *X1, MPR *Y1, MPR **Xptr, MPR **Yptr, MPR *A1, MPR *A2, MPR *A3, MPR *A4, MPR *A6, unsigned int n); 
void POWERXM(MPI *a, MPI *b, MPI *n, MPI **eptr, MPI **fptr, MPI *x, MPI *p); 
void POWERXm(USL a, USL b, USL n, USL *eptr, USL *fptr, USL x, USL p); 
void PRINT_DEFECT(); 
void PRINTDR(unsigned int d, MPR *Mptr); 
void PRINTI(MPI *Mptr); 
void PRINTIA(MPIA Mptr); 
void PRINTMATI(USI i1, USI i2, USI j1, USI j2, MPMATI *Mptr); 
void PRINTMATR(USI i1, USI i2, USI j1, USI j2, MPMATR *Mptr); 
void PRINTR(MPR *Aptr); 
void PRINTW1(USI n, USI r); 
void PRINTW2(USI n, USI r, USI m); 
void PRINTWW(); 
void QERATOSTHENES(MPI *N, USL base[], USL soln[], USI FBASE); 
void QSORTMPI0(MPI *A[], USI m, USI n); 
void QSORTMPI(MPI *A[], USI m, USI n); 
void QSORTMPIX(); 
void QSORTMATIX(); 
void QSORTMATI(MPMATI *Mptr, USI r, USI s); 
void REDUCTION(USI **M1, USI **M2, USI m, USI n, int SCAN[]); 
void REDUCTION1(USL **M1, USL **M2, USI m, USI n, USI m1bitcols, USI m2bitcols, int INDEX[], USI CTR[]); 
void RODI(MPMATI *Aptr, USI *T, USI j); 
void RODIP(MPMATI *Aptr, MPMATI *Pptr, USI *T, USI j); 
int SIGNI(MPI *I); 
void SCHNORRGCD(MPI *N); 
void SERRET(MPI *P, MPI **Xptr, MPI **Yptr); 
void SHALLIT(); 
void SHORTESTTTX(); 
void SHORTESTTT(MPMATI *AA, MPI *BOUND); 
void SMITH(); 
void SORTI(USI *T, USI nz); 
void SPRINTDR(char *buffer, unsigned int d, MPR *Mptr); 
void SPRINTI(char *buffer, MPI *Mptr); 
void SPRINTR(char *buffer, MPR *Aptr); 
void STEP7(USI i, USI k, MPMATI **Lptr, MPI *D[]); 
void STEP8(USI k, MPMATI **B1ptr, MPMATI **Lptr, MPMATI **Eptr, USI i); 
void STEP80(USI k, MPMATI **B1ptr, MPMATI **Lptr); 
void SelOpt(); 
void TryAgain(); 
void ZEROTESTI(USI i, MPMATI *Mptr, USI *p, USI *q); 
void clean_symtab(); 
void clearscreen(); 
void doit(FILE *f, char *valstr, MPI *Eptr, MPI *Rptr); 
void fpecatch(); 
void ifree2(USL **pa, USI row, USI col); 
void init(); 
void print_array(USL **M, int rows, int cols); 
void sfree(void *ptr, size_t nbytes, char *errorfile, int errorline); 
void undoit(FILE *f, char *unencstr, MPI *Dptr, MPI *Rptr); 
void warning(char *s, char *t); 
void yyerror(); 
MPMATI *LLLGCD(MPMATI *DD, MPI **Aptr, USI m, USI m1, USI n1); 
void REDUCE(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPI *D[], MPI *A[]); 
void SWAP1(USI i, USI k, MPMATI **Lptr, MPI *D[]); 
void SWAP2(USI k, MPMATI **B1ptr, MPMATI **Lptr, MPI *A[]); 
void LLLGCDX(); 
void JACOBIGCDX(); 
MPMATI *JACOBIGCD(MPMATI *DD, MPI **Aptr, USI m); 
USI COLSEEKI0(MPMATI *A, USI i, USI j); 
void SCHNORRHERMITE(MPI *N); 
MPMATI *BASIS_REDUCTION000(MPMATI *Bptr, USI m1, USI n1, MPI *N); 
unsigned int STEP4000(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPI *D[], MPI *N); 
void STEP8000(USI k, MPMATI **B1ptr, MPMATI **Lptr, MPI *N); 
MPMATI *LLLHERMITE1(MPMATI *DD, MPMATI **Aptr, USI *rank, USI m1, USI n1); 
void REDUCE1(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPI *D[], MPMATI **Aptr, USI *col1, USI *col2); 
void SWAP21(USI k, MPMATI **Bptr, MPMATI **Lptr, MPMATI **Aptr); 
void LLLHERMITE1X(); 
void LLLMINUS(MPMATI **Aptr, MPMATI **Pptr, MPMATI **Lptr, USI j); 
MPMATI *SCALAR_ROWI(USI p, MPI *Aptr, MPMATI *Mptr); 
void GCD4(); 
void GCD5(); 
void GCD6(); 
MPMATI *SHORTESTT0(MPMATI *AA, MPI **XX[]); 
void LLLGCDMINUS(MPMATI **Pptr, MPMATI **Lptr, USI j); 
MPI *PERFECT_POWER(MPI *N); 
void CONVERGENTS(MPIA A, MPIA *P, MPIA *Q); 
void LAGRANGE(POLYI P, MPIA *AA, MPI *M); 
MPI *SUMI(MPI *A[], USL n); 
MPI *EFACTORX(MPI *N, MPI *M, MPI *P); 
void AXB(); 
void AXB1(); 
MPMATI *TRANSPOSEI(MPMATI *Mptr); 
unsigned int PIVOTI(MPMATI *Mptr, USI *rptr, USI *cptr, USI r, USI s); 
MPI *RANDOMI(MPI *X, MPI *P, MPI *T); 
void RANDOM_MATRIX(MPI *M, MPI *N, MPI *X, MPI *P, MPI *T); 
MPMATI *RANDOM_MATRIXA(USI m, USI n, MPI *X, MPI *P, MPI *T); 
MPMATI *RANDOM_MATRIXA3(USI m, USI n, MPI *X, MPI *P, MPI *T); 
MPMATI *JCOLSMATI(MPMATI *Mptr, MPMATI *Nptr); 
void TESTAXB(); 
MPI *HALFMOD(MPI *Aptr, MPI *Pptr); 
MPI *THREEI(); 
MPI *CHANGEL(long n); 
void CHANGELX(MPI *M); 
void FERMAT_QUOTIENT(MPI *N); 
MPMATI *LLLGCD0(MPMATI *DD, MPI **Aptr, USI m, USI m1, USI n1); 
MPR *MPI_TO_MPR(MPI *N); 
void LLLGCD0X(); 
void GCD10(); 
void GCD11(); 
void GCD33(); 
MPI *ABS_NEAREST_INTR(MPR *Aptr); 
MPMATI *LLLGCD0M(MPMATI *DD, MPI **Aptr, USI m, USI m1, USI n1); 
void SHORTEST(MPMATI *AA, MPI *I[], USI filename, USI number); 
MPI *EFACTOR(MPI *N, USI m, USI p); 
void SLVECTORX(); 
MPR *SLVECTOR(MPMATR *A, MPR *C, MPR **VALUE); 
void GCD_CONJ(); 
MPMATI *LLLGCDL(MPMATI *DD, MPI **Aptr, USI m, USI m1, USI n1, MPMATR**LMATRIX); 
MPI ***SHORTESTX(MPMATI *AA, MPI *I[], USI *counter); 
void GCD3(); 
void GCDCONJECTURE4(); 
void GCDCONJECTURE5(); 
void GCDCONJECTURE6(); 
void GCDCONJECTURE7(); 
void GCDCONJECTUREM(); 
void ABS_NEAREST_INTRX(); 
MPI *GEN_COLLATZ(MPI *Aptr, USL d, MPI *m[], MPI *X[]); 
void P_CYCLE(MPI *Aptr, USL d, MPI *m[], MPI *X[], USI c); 
unsigned int IS_CYCLE(MPI *Aptr, USL d, MPI *m[], MPI *X[], MPI *Z[], USI c); 
void CYCLE(USL d, MPI *m[], MPI *X[], USL INFINITY, USL RANGE); 
void CYCLEX(); 
MPI *MULTM3(MPI *A, MPI *B, MPI *C, MPI *M); 
MPI *MULTABCM(MPI *A, MPI *B, MPI *C, MPI *M); 
void POWER_CUBICM(MPI *X1, MPI *Y1, MPI **Xptr, MPI **Yptr, MPI *A1, MPI *A2, MPI *A3, MPI *A4, MPI *A6, unsigned int n, MPI *MODULUS); 
void ADD_CUBICM(MPI *X1, MPI *Y1, MPI *X2, MPI *Y2, MPI **Xptr, MPI **Yptr, MPI *A1, MPI *A2, MPI *A3, MPI *A4, MPI *A6, MPI *MODULUS); 
void ADD_CUBICMX(); 
void POWER_CUBICMX(); 
void ORDER_CUBICMX(); 
unsigned int ORDER_CUBICM(MPI *X1, MPI *Y1, MPI *A1, MPI *A2, MPI *A3, MPI *A4, MPI *A6, MPI *MODULUS); 
void ORDER_CUBICRX(); 
unsigned int ORDER_CUBICR(MPR *X1, MPR *Y1, MPR *A1, MPR *A2, MPR *A3, MPR *A4, MPR *A6); 
MPI *LEASTQNR(MPI *P); 
MPI *LEASTQNRX(MPI *P); 
void EUCLID(MPI *Aptr, MPI *Bptr, MPIA *Q, MPIA *R, MPIA *S, MPIA *T, MPI **Dptr); 
 
void readme(); 
 
MPIA BUILDMPIA(); 
void ADD_TO_MPIA(MPIA MA, MPI *V, USL n); 
void FREEMPIA(MPIA MA); 
void MPIA_INSERT(MPIA MA, MPI *V, USL n); 
void CORNACCHIA(MPI *A, MPI *B, MPI *M); 
int COMPARE_DIGITS(MPI *M, MPI *N, MPI *U, MPI *V, USL b); 
MPI *SQROOT1(MPI *A, MPI *P, USL n); 
MPI *SQROOT2(MPI *A, USL n); 
MPI *SQROOT3(MPI *A, MPI *P, USL n, MPI**EXPONENT); 
MPI *SQROOT(MPI *A, MPI *N, MPIA *SOL, MPI **MODULUS, USI *l); 
unsigned int SURD(MPI *D, MPI *T, MPI *U, MPI *V, MPIA *AA_SURD, MPIA *U_SURD, MPIA *V_SURD, MPIA *P_SURD, MPIA *Q_SURD, USI surd_flag); 
MPI *SURDX(MPI *D, MPI *T, MPI *U, MPI *V, MPIA *AA_SURD, MPIA *U_ARRAY,MPIA *V_ARRAY, MPIA *P_ARRAY, MPIA *Q_ARRAY); 
void PATZ(MPI *D, MPI *N); 
MPI *PATZX(MPI *D, MPI *N); 
MPI *CORNACCHIAX(MPI *A, MPI *B, MPI *M); 
MPI *SQROOTX(MPI *A, MPI *N, MPIA *Y, MPI **M, USI *l); 
MPI *QUADRATIC(MPI *A, MPI *B, MPI *C, MPI *N, MPIA *SOL); 
MPI *QUADRATICX(MPI *A, MPI *B, MPI *C, MPI *N, MPIA *SOL); 
void GAUSS(MPI *A, MPI *B, MPI *C, MPI *N, MPI **alpha, MPI **gamma, MPI **M); 
void BINARYFORM(MPI *A, MPI *B, MPI *C, MPI *N, MPIA *FSX1, MPIA *FSY1, USI *N1, USI FLAG, USI verb); 
void BINARYFORM1(MPI *A, MPI *B, MPI *C, MPI *N, MPI *VERB); 
MPI *HALFMODX(MPI *Aptr, MPI *Pptr); 
 
void LOG(MPI *A, MPI *B, MPI *D, MPI *R, MPIA *M, MPI **L); 
MPI *LOGX(MPI *A, MPI *B, MPI *D, MPI *R, MPIA *M, MPI **L); 
MPI *CEILINGI(MPI *A, MPI *B); 
MPI *CEILINGIX(MPI *A, MPI *B); 
void TESTLOG1(MPI *A, MPI *B, MPI *D, MPI *R); 
void TESTLOG(MPI *A, MPI *B, MPI *D, MPI *M, MPI *N); 
MPI *TESTLOGX(MPI *A, MPI *B, MPI *D, MPI *M, MPI *N); 
MPI *PRIME_GENERATOR(MPI *M, MPI *N); 
MPI *PRIME_GENERATORX(MPI *M, MPI *N); 
USI SIGN_COUNT(MPIA A); 
MPI *STURM_SEQUENCE(POLYI P, MPI *B, MPI *E); 
POLYI PRIMITIVEPI_(POLYI P); 
void NEXTPHI(USL p, USL *gptr, MPIA *b, MPIA *coef); 
int NOTYET(USL n, USL i, USL *qptr); 
int LPF(USL n); 
POLYI CYCLOTOMIC(MPI *N); 
unsigned int SQUAREFREE_TEST1000(USL n); 
unsigned int PERIOD(MPI *D, MPI *U, MPI *V); 
unsigned int CHECK_UVARRAYS(MPI *U, MPI *Y); 
USI POS(MPI *D); 
MPI *POSX(MPI *D); 
USI NEG(MPI *D, MPI *FLAG, MPI *TABLE_FLAG); 
MPI *NEGX(MPI *D, MPI *FLAG); 
MPI *NEARINT(MPI *M, MPI *N); 
MPI *NEARINTX(MPI *M, MPI *N); 
USI REDUCE_NEG(MPI *A, MPI *B, MPI *C); 
MPI *REDUCE_NEGX(MPI *A, MPI *B, MPI *C); 
MPI *REDUCE_POSX(MPI *A, MPI *B, MPI *C); 
USI REDUCE_POS(MPI *A, MPI *B, MPI *C); 
USI CYCLE_PERIOD(MPI *D, MPI *U, MPI *V, USI i, int sign); 
USI POS0(MPI *D); 
MPI *POS0X(MPI *D); 
MPI *TABLENEGX(MPI *M, MPI *N); 
USL TABLENEG(MPI *M, MPI *N); 
USL TABLEPOS(MPI *M, MPI *N); 
USI POS1(MPI *D, int *norm); 
MPI *TABLEPOSX(MPI *M, MPI *N); 
USL POSITIVITY(MPI *A, MPI *B, MPI *C, MPI *D); 
USL NPROD(USL l,USL m); 
MPI *REFINE(MPI *A, MPI *B, MPI *C, MPI *D); 
USL RANEY(MPI *P, MPI *B, MPI *Q, MPI *R); 
USL DAVISON(USL l, USL m, USL n); 
MPI *DAVISONX(MPI *L, MPI *M, MPI *N); 
USL RANEY1(MPI *P, MPI *Q, MPI *R, MPI *S); 
MPI *RANEY1X(MPI *P, MPI *Q, MPI *R, MPI *S); 
MPI *UNIMODULARX(MPI *P, MPI *Q, MPI *R, MPI *S); 
USL UNIMODULAR(MPI *P, MPI *Q, MPI *R, MPI *S); 
MPI *MAXMPI(MPI *I, MPI *J); 
MPI *MINMPI(MPI *I, MPI *J); 
void MULT_PADIC(MPIA A, MPIA B, MPI *P, MPIA *PROD, USI m, USI n, USI *l); 
int RSV_PADIC(MPIA A, MPIA B, USI m, USI n); 
void SUB_PADIC(MPIA A, MPIA B, MPI *P, MPIA *DIFF, USI m, USI n, USI *l); 
void BASE_PADIC(MPI *B, MPI *N, MPIA *BASE, USI *j); 
void TWOADICSQRT(MPI *A, USI n, MPIA *DIGITS); 
MPI *TWOADICSQRTX(MPI *A, MPI *N, MPIA *DIGITS); 
void PADICSQRT(MPI *A, USI n, MPI *P, MPIA *DIGITS); 
MPI *PADICSQRTX(MPI *A, MPI *N, MPI *P, MPIA *DIGITS); 
MPI *SIGMAK(USI k, MPI *N); 
MPI *SIGMAKX(MPI *K, MPI *N); 
MPI *TAU(USI n); 
MPI *TAUX(MPI *N); 
MPI *TAU_PRIMEPOWERX(MPI *N, MPI *P); 
MPI *TAU_PRIMEPOWER(USI n, USI p); 
MPI *TAU_COMPOSITEX(MPI *N); 
MPI *TAU_COMPOSITE(USI n); 
USI REDUCE_NEG0(MPI *A, MPI *B, MPI *C, MPI **AA, MPI **BB, MPI **CC, MPI **alpha, MPI **beta, MPI **gamma, MPI **delta, USI print_flag); 
USI REP_DEFINITE(MPI *A, MPI *B, MPI *C, MPI *M, USI print_flag); 
MPI *REP_DEFINITEX(MPI *A, MPI *B, MPI *C, MPI *M, MPI *PRINT_FLAG); 
void AUTOMORPH(MPI *A, MPI *B, MPI *D, MPI *T, MPI *U, MPI *X, MPI *Y, MPI **XX, MPI **YY); 
void POWERD(MPI *A, MPI *B, MPI *D, MPI *N, MPI **AA, MPI **BB); 
MPI *EUCLIDI1(MPI *M, MPI *N); 
MPI *CFRACN(MPI *N); 
MPI  *CFRAC_PERIOD(MPI *D); 
#endif