#pragma off (check_stack);

#include "malloc.c"  //Feb14, 98
//see #include modes1.h below

extern int genprecdeclarations( );
extern int zprnt(unsigned int *z4prnt);                      
extern int zbreak();
extern int zshiftleft(unsigned int *z7);                     
extern int zshftrt(unsigned int *z3);
extern int zconinttomp(int zkk);
extern int zconinttomp(unsigned int zkk);   //added Nov.27,99
extern int zchs(unsigned int *z1);
extern int zrecall(unsigned int *z5);
extern int zstore(unsigned int *z1);
extern int zadd(unsigned int *z8, unsigned int *z9);
extern int zsub(unsigned int *z8, unsigned int *z9);
extern int zmultint(unsigned int *zx1, unsigned int y11);
extern int zmultint(unsigned int *zx1, int y11);     //added Nov.27,99
extern int zmult(unsigned int *z1,unsigned int *z2);
extern int zdivint(unsigned int *zxx1, unsigned int zkk);
extern int zdivint(unsigned int *zxx1, int zkk);      //added Nov.27.99
extern int zrecip(unsigned int *zdivy);
extern int zincreaseprecision(unsigned int *z1, int zip);
extern int zdecreaseprecision(unsigned int *z1, int zip1, int zip2);
extern int zdiv(unsigned int *z1div, unsigned int *z2div);
extern int zabs(unsigned int *z1);
extern int zsqrt(unsigned int *zz1);
extern int zconftomp(double zff); 
extern int zcontobase32(unsigned int *zz4);
extern int zxtonth(unsigned int *zzz1,int zip);
extern int zconmptof(unsigned int *z1);
extern int zsuppi();
extern int zsetzone();
extern int zzero(unsigned int *z1);
extern int zpi();
extern int zfracpart(unsigned int *zz2);
extern int zcos(unsigned int *zz3);
extern int zsin(unsigned int *zz4);
extern int zcosmajor(unsigned int *zz22);
extern int zsinmajor(unsigned int *zz33);
extern int znterms(float zf);
extern int zarcsin(unsigned int *zzz1);                        
extern int zsupe();
extern int zee(); 
extern int zexpfcnmajor(unsigned int *zz33);
extern int zexp(unsigned int *zz4);
extern int zlogsp2();
extern int zintpart(unsigned int *z1); 
extern int zsuplogsp();
extern int zlogmajor(unsigned int *zz22);
extern int zlog(unsigned int *zz3);                   
extern int zconinputtomp(unsigned int *zinput);
extern int zarctan(unsigned int *zz5);                

extern int zgenprecmem();                                                                         
extern int zmemforreal();
extern int zmemforvector();
extern int zmemformatrix();
extern int zmemforcomplex();
extern int zmemforcomplexvector();
extern int zmemforcomplexmatrix();
extern int zmemory(int ns,int nv,int nm,int ncs,int ncv,int ncm);
double zff=precision+1;                
double zgg=zff*log(10000)/(32*log(2)); 
const int prec00=zgg;  
const int prec0=prec00+2;                    
int prec=prec0;      //change prec (set prec)
const int zprecpad=prec0+0xa;  //next three are paddings in memory allocation
const int zmaxsizepad=zmaxsize+3;
const int cmaxsizepad=cmaxsize+3;
int prec10=precision+1;
int zsuperprec=prec+5; 
unsigned int zhex99=0xffffffff; 

#include "zclasses.h"     
unsigned int depthcount=2;

realscalar x_ram;unsigned int *x=x_ram.s;
realscalar y_ram;unsigned int *y=y_ram.s;
realscalar z_ram;unsigned int *z=z_ram.s;
realscalar z11_ram;unsigned int *z11=z11_ram.s;
realscalar z22_ram;unsigned int *z22=z22_ram.s;
realscalar zL_ram;unsigned int *zL=zL_ram.s;
realscalar zden_ram;unsigned int *zden=zden_ram.s;
realscalar zrem_ram;unsigned int *zrem=zrem_ram.s;


//int xorig=x; changed 1/2/00
//int yorig=y;
//int zorig=z;
//int z11orig=z11;
//int zremorig=zrem;
//int zdenorig=zden;
//int zLorig=zL;
unsigned int *xp1=x+1;
unsigned int *zp1=z+1;
realscalar zfake_ram;unsigned int *zfake=zfake_ram.s;  
realscalar zz_ram;unsigned int *zz=zz_ram.s;
realscalar z1_ram;unsigned int *z1=z1_ram.s;
realscalar z2_ram;unsigned int *z2=z2_ram.s;
realscalar z3_ram;unsigned int *z3=z3_ram.s;
realscalar z5_ram;unsigned int *z5=z5_ram.s;
realscalar z7_ram;unsigned int *z7=z7_ram.s;
realscalar z8_ram;unsigned int *z8=z8_ram.s;
realscalar z9_ram;unsigned int *z9=z9_ram.s;
realscalar z1div_ram;unsigned int *z1div=z1div_ram.s;
realscalar z2div_ram;unsigned int *z2div=z2div_ram.s;
realscalar zx1_ram;unsigned int *zx1=zx1_ram.s;
realscalar zy1_ram;unsigned int *zy1=zy1_ram.s;
realscalar z81_ram;unsigned int *z81=z81_ram.s;
realscalar z91_ram;unsigned int *z91=z91_ram.s;
realscalar zxx1_ram;unsigned int *zxx1=zxx1_ram.s;
realscalar z4prnt_ram;unsigned int *z4prnt=z4prnt_ram.s;
realscalar zround4_ram;unsigned int *zround4=zround4_ram.s;
realscalar z4prntsave_ram;unsigned int *z4prntsave=z4prntsave_ram.s;
realscalar zsupereps_ram;unsigned int *zsupereps=zsupereps_ram.s;
realscalar zdivy_ram;unsigned int *zdivy=zdivy_ram.s;
realscalar zdivy1_ram;unsigned int *zdivy1=zdivy1_ram.s;
realscalar zout_ram;unsigned int *zout=zout_ram.s;
realscalar zz1_ram;unsigned int *zz1=zz1_ram.s;
realscalar zz2_ram;unsigned int *zz2=zz2_ram.s;
realscalar zz3_ram;unsigned int *zz3=zz3_ram.s;
realscalar zz4_ram;unsigned int *zz4=zz4_ram.s;
realscalar zz5_ram;unsigned int *zz5=zz5_ram.s;
realscalar zz11_ram;unsigned int *zz11=zz11_ram.s;
realscalar zz22_ram;unsigned int *zz22=zz22_ram.s;
realscalar zz33_ram;unsigned int *zz33=zz33_ram.s;
realscalar zz111_ram;unsigned int *zz111=zz111_ram.s;
realscalar zconfac_ram;unsigned int *zconfac=zconfac_ram.s;
realscalar zzz1_ram;unsigned int *zzz1=zzz1_ram.s;
realscalar zzz2_ram;unsigned int *zzz2=zzz2_ram.s;
realscalar zzz3_ram;unsigned int *zzz3=zzz3_ram.s;
realscalar zzz25_ram;unsigned int *zzz25=zzz25_ram.s;
realscalar ze_ram;unsigned int *ze=ze_ram.s;
realscalar zone_ram;unsigned int *zone=zone_ram.s;
realscalar zsuperpi_ram;unsigned int *zsuperpi=zsuperpi_ram.s;
realscalar z10_ram;unsigned int *z10=z10_ram.s;
realscalar zz44_ram;unsigned int *zz44=zz44_ram.s;
realscalar zz55_ram;unsigned int *zz55=zz55_ram.s;
realscalar zzz4_ram;unsigned int *zzz4=zzz4_ram.s;
realscalar zzz5_ram;unsigned int *zzz5=zzz5_ram.s;
realscalar zsupere_ram;unsigned int *zsupere=zsupere_ram.s;
realscalar zsuperlogsp2_ram;unsigned int *zsuperlogsp2=zsuperlogsp2_ram.s;
realscalar zzp3_ram;unsigned int *zzp3=zzp3_ram.s;

int cwidebug;
int cwjdebug;
int cwkdebug;

unsigned int zdivisor;
unsigned int zcarryprnt,zlftemp;
unsigned int zugh1,zugh2,zugh8,zugh9;
unsigned int zftemp1,zftemp2,zl2,za,zd,zcar;
unsigned int y11,y2;                             
unsigned int zy11, zkk;                    
int zr;                              //not unsigned
int maxinmode7;
int precp1mzkisky;                         
int precmzkn;                                     
int precp1mzkn;                           
int zkn,zknp2,precp1a;     //98
unsigned int zp;
unsigned int zcarry;
float zf;                                        
unsigned int zkk2;
int zpqr;
int zip,zip1,zip2;                               
int zprecsave;
unsigned int zlint1,zlint2,zlint28;  //used in assembly language
int zaddress;                       //used in assembly language
double zftenth=4.294967296e9;                                 
unsigned int znum;                                            
unsigned int *zinput, *zinpu, *winput;         
char *zmessage;                                                  
int zqqq;                                       
int zmem=0;
int zmempr,zmemprpr,zmemprprpr,zreturnmem;
int ns,nv,nm,ncs,ncv,ncm;

//#include "modes1.hh"   //this uses only origins in assembly
                       //and allows x_ram way of declaring x
#include "modenoas.sem"  

int zigenprecdeclarations=genprecdeclarations();

int genprecdeclarations()
  {int zi,zj;
   for (zi=1;zi<100;zi++)    //initialize assembly language variables
      {x[zi]=0;
       y[zi]=0;
       z[zi]=0;
       z11[zi]=0;
      }
   x[0]=0x40000000;
   y[0]=0x40000000;
   z[0]=0x40000000;    
   z11[0]=0x40000000;
   zzero(z22);
   zmessage = new char [50];                
   zinput = new unsigned int [precision+0xa];
   zinpu = new unsigned int [precision+0xa];
   winput = new unsigned int [precision+0xa];
   return 0;
  }


unsigned int ipiz,jpiz,xL,xR;   

int zigenprecmem=zgenprecmem();
int zgenprecmem()
{int zi;
 unsigned int zj; 
 char zapo;
 zmem=zmem+19*sizeof(zi)+1629*sizeof(zj);
 zmemforreal();
 zmem=zmem+51*zreturnmem+sizeof(zff);    //special cases treated as ordinary
 zmem=zmem+sizeof(zf)+sizeof(zftenth)+51*sizeof(zapo);
 return 0;
}

int zmemory(int ns,int nv,int nm,int ncs,int ncv, int ncm) 
{zmemforreal();
 zmem=zmem+ns*zreturnmem; //two real mp declared above
 zmemforvector();
 zmem=zmem+nv*zreturnmem;   //one real vector declared above
 zmemformatrix();
 zmem=zmem+nm*zreturnmem;   //one real matrix declared above
 zmemforcomplex();
 zmem=zmem+ncs*zreturnmem;
 zmemforcomplexvector();
 zmem=zmem+ncv*zreturnmem;
 zmemforcomplexmatrix();
 zmem=zmem+ncm*zreturnmem;
 cerr<<"the memory required is "<<zmem<<" bytes"<<'\n';
 zmessage=" ";
 zbreak();
 return 0;               //these account for most of the memory requirements
}


int zmemforreal()       
{unsigned int zi;
 int *guh;
 zreturnmem=sizeof(guh)+zprecpad*sizeof(zi);  //first is size of pointer
 return 0;                                    //to _ram and int * 
}

int zmemforvector()
{unsigned int wi;
 int *guh;
 zreturnmem=(1+zmaxsizepad)*sizeof(guh)+zprecpad*zmaxsizepad*sizeof(wi);
 return 0;                          //first is size of pointers
}                                   //to _ram and int * *

int zmemformatrix()
{unsigned int wi;
 int *guh;
 zreturnmem=(1+zmaxsizepad+zmaxsizepad*zmaxsizepad)*sizeof(guh)+zprecpad*zmaxsizepad*zmaxsizepad*sizeof(wi);
 return 0;                        //first is memory required by pointers
}                                 //to _ram and int * *

int zmemforcomplex()
 {unsigned int zi;
  int *guh;
  zreturnmem=2*sizeof(guh)+zprecpad*2*sizeof(zi);
  return 0;
 }

int zmemforcomplexvector()
 {unsigned int zi;
  int *guh;
  zreturnmem=2*(1+cmaxsizepad)*sizeof(guh)+zprecpad*cmaxsizepad*2*sizeof(zi);
  return 0;
 }

int zmemforcomplexmatrix()
 {unsigned int zi;
  int *guh;
  zreturnmem=2*(1+cmaxsizepad+cmaxsizepad*cmaxsizepad)*sizeof(guh)+zprecpad*cmaxsizepad*cmaxsizepad*2*sizeof(zi);
  return 0;
 }

int zprnt(unsigned int *z4prnt)
{int zi,zj,zk,zsignflag,zpower10,zbee;
 unsigned int zsavetheprec;

/*
cout<<z4prnt[prec+1]<<" "<<z4prnt[prec]<<" "<<z4prnt[prec-1]<<"..."<<z4prnt[0]<<'\n';
cout<<"got here in zprnt"<<'\n';
cin>>qqq;
*/

for (zi=0;zi<prec+2;zi++) z4prntsave[zi]=z[zi];
for (zi=1;zi<prec+2;zi++) zround4[zi+1]=z4prnt[zi];
zround4[0]=z4prnt[0];
zround4[1]=0;
zsavetheprec=prec;
prec++;
int precp1=prec+1;
if (zround4[prec]==0)               //printing zero
 {cout<<"+.";
  for (zi=1;zi<4*prec10-3;zi++)
     {zk=zi>>6;
      zk=zk<<6;
      if (zi==zk) cout<<'\n';
      cout<<"0";
     }
   cout<<" E 0"<<'\n';
   goto zafterzero;                  //end of zero case
  }
zsignflag=1;
if (zround4[precp1]==0)
  {zsignflag=-1;
   zround4[precp1]=2;}
zpower10=1;

/*
cout<<"got to start of zloop in zprnt"<<'\n';
cin>>qqq;
*/

zloop:
    if(zround4[0]==0x40000001)
      {if(zround4[prec]<10) goto zloopend;}
    if(zround4[0] <0x40000001)
      {zmultint(zround4,10);
       zstore(zround4);
       zpower10=zpower10-1;
       goto zloop;
      }
   zdivint(zround4,10); 
   zstore(zround4);
   zpower10++;
   goto zloop;
zloopend:

/*
cout<<"got here 2 in zprnt"<<'\n';
cin>>qqq;
*/

if (zsignflag==1)
  {cout<<"+.";}
if (zsignflag==-1) 
   {cout<<"-.";}
for (zi=1;zi<4*prec10-2;zi++)    
  {zk=zi/64;
   zk=64*zk;
   if (zi==zk) cout<<'\n';
   zbee=zround4[prec];
   zround4[prec]=0;
   zcarryprnt=0;
   for (zj=1;zj<precp1;zj++)
      {zugh1=zround4[zj];
       moxy1();                     //multiplies by 10
       zround4[zj]=zugh1;
      }
   if (zi==4*prec10-4)
      {if (zround4[prec]>4 && zbee<9) zbee++;
       cout<<zbee;
       goto zbeeout;
      }                       
   cout<<zbee;
  }
zbeeout:
  cout<<" E "<<zpower10<<'\n';
  zafterzero:
  prec=zsavetheprec;
  for (zi=0;zi<prec+2;zi++) z[zi]=z4prntsave[zi];
  return 0;
}

int zbreak()                                                           
{ cerr<<zmessage <<'\n';
  cerr<<"enter any character to continue ";
  cin >> zqqq;
  cin.clear();
  int nextChar;
  while( (nextChar = cin.get()) != '\n' && nextChar != EOF ){}
  cin.clear();
  cerr <<'\n';

  return 0;
}

int zshiftleft(unsigned int *z7)
{ int zi;                         
  for (zi=prec; zi>=2; zi--)
    {z7[zi]=z7[zi-1];}
  z7[1]=0;
  z7[0]--;          
  return 0;
}

int zshftrt(unsigned int *z3)                    
{ int zi2,precmzrp1,precp1;
  precp1=prec+1;
  precmzrp1=precp1-zr;
  z3[0]+=zr;
  if (z3[zr]>0x7fffffff && z3[zr+1]<0xffffffff) z3[zr+1]++;
  for (zi2=1; zi2<precmzrp1; zi2++)
     {z3[zi2]=z3[zi2+zr];}
  for (zi2=precmzrp1; zi2<precp1; zi2++)
     {z3[zi2] = 0;}
  return 0;
}

int zconinttomp(int zkk)                                  
{
   int zi;
   for (zi=1;zi<prec;zi++)
      {z[zi]=0;}
   z[prec]=abs(zkk);
   if (zkk>=0) z[prec+1]=2; else z[prec+1]=0;
   z[0]=0x40000001;
   return 0;
}

int zconinttomp(unsigned int zkk)     //added Nov27,99                           
{
   int zi;
   for (zi=1;zi<prec;zi++)
      {z[zi]=0;}
   z[prec]=zkk;
   z[prec+1]=2; 
   z[0]=0x40000001;
   return 0;
}


int zchs(unsigned int *z1)
{int precp1;
   precp1=prec+1;
   z1[precp1]=2-z1[precp1];  
   return 0;
}

int zrecall(unsigned int *z5)                                
{
   int zi;
   for (zi=0;zi<prec+2;zi++)
      {z[zi]=z5[zi];}
   return 0;
}

int zstore(unsigned int *z1)                                                   
{  int zi,zuprecp2;
   zuprecp2=prec+2;
   for (zi=0; zi<zuprecp2; zi++) z1[zi] = z[zi];
   return 0;
}


int zadd(unsigned int *z8, unsigned int *z9)                       
{ int zi,zj;
  precp1a=prec+1;
  int precp2=prec+2; 
  int precm1=prec-1;
  int z81x=z8[precp1a];
  int z91x=z9[precp1a];
  if (z8[prec]==0)
     {for (zi=0;zi<precp2;zi++) z[zi] = z9[zi];
      return 0;
     }
  if (z9[prec]==0)     
     {for (zi=0;zi<precp2;zi++) z[zi]= z8[zi];
      return 0;
     }
  if (z81x+z91x!=2)
   {for (zi=0;zi<precp1a;zi++)  
        {x[zi]=z8[zi];           
         y[zi]=z9[zi];}            
             
    if (x[0]==y[0]) 
      {z[0]=x[0];
       x[precp1a]=0;     //could be done in assembly
       y[precp1a]=0; 
       z[precp1a]=0;      //could be done in assembly
       mode4();                
       if (z[precp1a]==1)
          {if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;  
           for (zi=1;zi<precp1a;zi++) z[zi]=z[zi+1];                   
           z[0]++;
          }
       z[precp1a]=z81x;                     
       return 0;
      }

    if (x[0]>y[0])             
      {z[0]=x[0];
       zr = x[0] - y[0];
       if (zr > precm1)
         {for (zi=1; zi<precp1a; zi++) z[zi] = x[zi];
          z[precp1a]=z81x;                     
          return 0;} 
       int precmzrp11=precp1a-zr;
       y[0]+=zr;
       if (y[zr]>0x7fffffff && y[zr+1]<0xffffffff) y[zr+1]++;
       for (zi=1; zi<precmzrp11; zi++) y[zi]=y[zi+zr];
       for (zi=precmzrp11; zi<precp1a; zi++) y[zi] = 0;
       x[precp1a]=0;   
       y[precp1a]=0; 
       z[precp1a]=0;
       mode4();                
       if (z[precp1a]==1)
          {if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;  
           for (zi=1;zi<precp1a;zi++) z[zi]=z[zi+1];                   
           z[0]++;
          }
       z[precp1a]=z81x;                     
       return 0;
      }

    
       z[0]=y[0];
       zr=y[0]-x[0];
       if (zr>precm1)
         {for (zi=1; zi<precp1a; zi++) z[zi] = y[zi];  
          z[precp1a]=z81x;                     
          return 0;} 
       int precmzrp12=precp1a-zr; 
       x[0]+=zr;
       if (x[zr]>0x7fffffff && x[zr+1]<0xffffffff) x[zr+1]++;
       for (zi=1; zi<precmzrp12; zi++) x[zi]=x[zi+zr];
       for (zi=precmzrp12; zi<precp1a; zi++) x[zi] = 0;
       x[precp1a]=0;   
       y[precp1a]=0; 
       z[precp1a]=0;
       mode4();                
       if (z[precp1a]==1)
          {if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;  
           for (zi=1;zi<precp1a;zi++) z[zi]=z[zi+1];                   
           z[0]++;
          }
       z[precp1a]=z81x;                     
       return 0;
         
   }

  
    if (z81x == 0)              //both-: z8-z9 = (-z9)-(-z8) = (-z9)+~(-z8)      
        {for (zi=0;zi<precp1a;zi++)  
           {x[zi]=z9[zi];  
            y[zi]=z8[zi];}            
        }
    else                         //both+: z8-z9 = z8 + ~z9 
        {for (zi=0;zi<precp1a;zi++)  
           {x[zi]=z8[zi];           
            y[zi]=z9[zi];}            
        }

    if (x[0]==y[0]) 
       {z[0]=x[0];
        for (zi=1;zi<precp1a;zi++) y[zi]=0xffffffff-y[zi];
        x[precp1a]=0;     
        y[precp1a]=0;
        z[precp1a]=0;
        mode4();                
        if (z[precp1a]==0) for (zi=1;zi<precp1a;zi++) z[zi]=0xffffffff-z[zi]; 
        else 
           {z[precp1a]=2;                   
            if (z[1]<0xffffffff) z[1]++;
           }
        for (zi=0; zi<prec; zi++)
           {if (z[prec]>0) return 0;
            for (zj=prec;zj>1;zj--) z[zj]=z[zj-1];
            z[1]=0;
            z[0]--;
           }
        return 0;
       }

    else if (x[0]>y[0]) 
        {z[0]=x[0];
         zr = x[0] - y[0];
         if (zr > precm1)
           {for (zi=1; zi<precp1a; zi++) z[zi] = x[zi];
            z[precp1a]=2;                                 
            return 0;}   
         int precmzrp13=precp1a-zr;    
         y[0]+=zr;
         if (y[zr]>0x7fffffff && y[zr+1]<0xffffffff) y[zr+1]++;
         for (zi=1; zi<precmzrp13; zi++) y[zi]=y[zi+zr];
         for (zi=precmzrp13; zi<precp1a; zi++) y[zi] = 0;
         for (zi=1;zi<precp1a;zi++) y[zi]=0xffffffff-y[zi];
         x[precp1a]=0;     
         y[precp1a]=0;
         z[precp1a]=0;
         mode4();                
         if (z[precp1a]==0) for (zi=1;zi<precp1a;zi++) z[zi]=0xffffffff-z[zi];
         else 
            {z[precp1a]=2;                   
             if (z[1]<0xffffffff) z[1]++;
            }
         for (zi=0; zi<prec; zi++)
            {if (z[prec]>0) return 0;
             for (zj=prec;zj>1;zj--) z[zj]=z[zj-1];
             z[1]=0;
             z[0]--;
            }
         return 0;
        }

    else
         z[0]=y[0];
         zr=y[0]-x[0];
         if (zr>precm1)
           {for (zi=1; zi<precp1a; zi++) z[zi] = y[zi];  
            z[precp1a]=0;
            return 0;}                              
         int precmzrp14=precp1a-zr;    
         x[0]+=zr;
         if (x[zr]>0x7fffffff && x[zr+1]<0xffffffff) x[zr+1]++;
         for (zi=1; zi<precmzrp14; zi++) x[zi]=x[zi+zr];
         for (zi=precmzrp14; zi<precp1a; zi++) x[zi] = 0;
         for (zi=1;zi<precp1a;zi++) y[zi]=0xffffffff-y[zi];
         x[precp1a]=0;     
         y[precp1a]=0;
         z[precp1a]=0;
         mode4();                
         if (z[precp1a]==0) for (zi=1;zi<precp1a;zi++) z[zi]=0xffffffff-z[zi];
         else 
            {z[precp1a]=2;                   
             if (z[1]<0xffffffff) z[1]++;
            }
         for (zi=0; zi<prec; zi++)
            {if (z[prec]>0) return 0;
             for (zj=prec;zj>1;zj--) z[zj]=z[zj-1];
             z[1]=0;
             z[0]--;
            }
         return 0;
}


int zsub(unsigned int *z8, unsigned int *z9)                       
{ int zi,zj;
  int precp1a=prec+1;
  int precm1=prec-1;
  if (z8[prec]==0)
     {for (zi=0;zi<precp1a;zi++) z[zi] = z9[zi];
      z[precp1a]=2-z9[precp1a];       
      return 0;
     }
  if (z9[prec]==0)     
     {for (zi=0;zi<precp1a;zi++) z[zi]= z8[zi];
      z[precp1a]=z8[precp1a];
      return 0;
     }
  int z81x=z8[precp1a];
  int z91x=z9[precp1a];
  if (z81x+z91x==2)
   {for (zi=0;zi<precp1a;zi++)  
        {x[zi]=z8[zi];           
         y[zi]=z9[zi];}            
             
    if (x[0]==y[0]) 
      {z[0]=x[0];
       x[precp1a]=0;   
       y[precp1a]=0; 
       z[precp1a]=0;
       mode4();                
       if (z[precp1a]==1)
          {if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;  
           for (zi=1;zi<precp1a;zi++) z[zi]=z[zi+1];                   
           z[0]++;
          }
       z[precp1a]=z81x;                     
       return 0;
      }

    if (x[0]>y[0])             
      {z[0]=x[0];
       zr = x[0] - y[0];
       if (zr > precm1)
         {for (zi=1; zi<precp1a; zi++) z[zi] = x[zi];
          z[precp1a]=z81x;                     
          return 0;}
       int precmzrp11=precp1a-zr;
       y[0]+=zr;
       if (y[zr]>0x7fffffff && y[zr+1]<0xffffffff) y[zr+1]++;
       for (zi=1; zi<precmzrp11; zi++) y[zi]=y[zi+zr];
       for (zi=precmzrp11; zi<precp1a; zi++) y[zi] = 0;
       x[precp1a]=0;   
       y[precp1a]=0; 
       z[precp1a]=0;
       mode4();                
       if (z[precp1a]==1)
          {if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;  
           for (zi=1;zi<precp1a;zi++) z[zi]=z[zi+1];                   
           z[0]++;
          }
       z[precp1a]=z81x;                     
       return 0;
      }
           
       z[0]=y[0];
       zr=y[0]-x[0];
       if (zr>precm1)
         {for (zi=1; zi<precp1a; zi++) z[zi] = y[zi];  
          z[precp1a]=z81x;                     
          return 0;} 
       int precmzrp12=precp1a-zr; 
       x[0]+=zr;
       if (x[zr]>0x7fffffff && x[zr+1]<0xffffffff) x[zr+1]++;
       for (zi=1; zi<precmzrp12; zi++) x[zi]=x[zi+zr];
       for (zi=precmzrp12; zi<precp1a; zi++) x[zi] = 0;
       x[precp1a]=0;   
       y[precp1a]=0; 
       z[precp1a]=0;
       mode4();                
       if (z[precp1a]==1)
          {if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;  
           for (zi=1;zi<precp1a;zi++) z[zi]=z[zi+1];                   
           z[0]++;
          }
       z[precp1a]=z81x;                     
       return 0;
         
   }

  else
    if (z81x == 0)               //both-: z8-z9 = (-z9)-(-z8) = (-z9)+~(-z8)      
        {for (zi=0;zi<precp1a;zi++)  
           {x[zi]=z9[zi];  
            y[zi]=z8[zi];}            
        }
    else                         //both+: z8-z9 = z8 + ~z9 
        {for (zi=0;zi<precp1a;zi++)  
           {x[zi]=z8[zi];           
            y[zi]=z9[zi];}            
        }

    if (x[0]==y[0]) 
       {z[0]=x[0];
        for (zi=1;zi<precp1a;zi++) y[zi]=0xffffffff-y[zi];
        x[precp1a]=0;     
        y[precp1a]=0;
        z[precp1a]=0;
        mode4();                
        if (z[precp1a]==0) for (zi=1;zi<precp1a;zi++) z[zi]=0xffffffff-z[zi];
        else 
           {z[precp1a]=2;                   
            if (z[1]<0xffffffff) z[1]++;
           }
        for (zi=0; zi<prec; zi++)
           {if (z[prec]>0) return 0;
            for (zj=prec;zj>1;zj--) z[zj]=z[zj-1];
            z[1]=0;
            z[0]--;
           }
        return 0;
       }

    if (x[0]>y[0]) 
        {precm1=prec-1;
         z[0]=x[0];
         zr = x[0] - y[0];
         if (zr > precm1)
           {for (zi=1; zi<precp1a; zi++) z[zi] = x[zi];
            z[precp1a]=2;                                 
            return 0;}   
         int precmzrp13=precp1a-zr;    
         y[0]+=zr;
         if (y[zr]>0x7fffffff && y[zr+1]<0xffffffff) y[zr+1]++;
         for (zi=1; zi<precmzrp13; zi++) y[zi]=y[zi+zr];
         for (zi=precmzrp13; zi<precp1a; zi++) y[zi] = 0;
         for (zi=1;zi<precp1a;zi++) y[zi]=0xffffffff-y[zi];
         x[precp1a]=0;     
         y[precp1a]=0;
         z[precp1a]=0;
         mode4();                
         if (z[precp1a]==0) for (zi=1;zi<precp1a;zi++) z[zi]=0xffffffff-z[zi];
         else 
            {z[precp1a]=2;                   
             if (z[1]<0xffffffff) z[1]++;
            }
         for (zi=0; zi<prec; zi++)
            {if (z[prec]>0) return 0;
             for (zj=prec;zj>1;zj--) z[zj]=z[zj-1];
             z[1]=0;
             z[0]--;
            }
         return 0;
        }

    
         precm1=prec-1;
         z[0]=y[0];
         zr=y[0]-x[0];
         if (zr>precm1)
           {for (zi=1; zi<precp1a; zi++) z[zi] = y[zi];  
            z[precp1a]=0;
            return 0;}                              
         int precmzrp14=precp1a-zr;    
         x[0]+=zr;
         if (x[zr]>0x7fffffff && x[zr+1]<0xffffffff) x[zr+1]++;
         for (zi=1; zi<precmzrp14; zi++) x[zi]=x[zi+zr];
         for (zi=precmzrp14; zi<precp1a; zi++) x[zi] = 0;
         for (zi=1;zi<precp1a;zi++) y[zi]=0xffffffff-y[zi];
         x[precp1a]=0;     
         y[precp1a]=0;
         z[precp1a]=0;
         mode4();                
         if (z[precp1a]==0) for (zi=1;zi<precp1a;zi++) z[zi]=0xffffffff-z[zi];
         else 
            {z[precp1a]=2;                   
             if (z[1]<0xffffffff) z[1]++;
            }
         for (zi=0; zi<prec; zi++)
            {if (z[prec]>0) return 0;
             for (zj=prec;zj>1;zj--) z[zj]=z[zj-1];
             z[1]=0;
             z[0]--;
            }
         return 0;
}


int zmultint(unsigned int *zx1,unsigned int y11)
{int zi,zk;                    
 int precp1=prec+1;
 int precp2=prec+2;
 if (zx1[prec]==0 || y11==0)
   {z[prec]=0;
    z[0]=0x40000000;
    z[precp1]=2;
    return 0;}
 int zxsignflag=zx1[precp1];
 for (zi=1;zi<precp1;zi++) x[zi]=zx1[zi];           
 x[precp1]=0;               
 z[precp1]=0;                          
 z[0]=zx1[0];
 zcarry=0;
 y2=y11;
 y2lb=y2>>16;           //left 16 bits of y2
 y2rb=y2<<16;
 y2rb=y2rb>>16;           //right 16 bits of y2

 for (zi=1;zi<precp2;zi++)
//   {mode5(x[zi],y11,zi);}
   {zugh1=x[zi];              //this is mode5() when assembly language used
    zugh1lb=zugh1>>16;     //left 16 bits of zugh1
    zugh1rb=zugh1<<16;
    zugh1rb=zugh1rb>>16;   //right 16 bits of zugh1
    rightright=zugh1rb*y2rb; //these are all 32 bits;
    rightleft=zugh1rb*y2lb;  
    leftright=zugh1lb*y2rb;
    leftleft=zugh1lb*y2lb;
    slot1=rightright+zcarry;
    if (slot1<rightright) slot3=0x00000001; else slot3=0;
    center=leftright+rightleft;
    if (center<leftright) slot3=slot3+0x00010000;
    lbofcenter=center>>16;   //break them into 16 bit lb and rb
    slot3=slot3+lbofcenter+leftleft;
    rbofcenter=center<<16;
    slot1=slot1+rbofcenter;
    if (slot1<rbofcenter) slot3=slot3+0x00000001;
    z[zi]=slot1;
    zcarry=slot3;
   }

 if (z[precp1]==0)             //no carry
   {z[precp1]=zxsignflag;            
    return 0;
   }
 if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;    //carry
 for (zk=2;zk<precp2;zk++) z[zk-1]=z[zk];
 z[0]++;
 z[precp1]=zxsignflag;            
 return 0;                        
}                          

int zmultint(unsigned int *zx1,int y11xx)   //added Nov.27,99
{int zi,zk;
 int precp1=prec+1;
 int precp2=prec+2;
 int y11=abs(y11xx);                 //Nov27,99
 if (zx1[prec]==0 || y11==0)
   {z[prec]=0;
    z[0]=0x40000000;
    z[precp1]=2;
    return 0;}
 int zxsignflag=zx1[precp1];
 for (zi=1;zi<precp1;zi++) x[zi]=zx1[zi];           
 x[precp1]=0;               
 z[precp1]=0;                          
 z[0]=zx1[0];
 zcarry=0;
 y2=y11;
 y2lb=y2>>16;           //left 16 bits of y2
 y2rb=y2<<16;
 y2rb=y2rb>>16;           //right 16 bits of y2
 for (zi=1;zi<precp2;zi++)
//  {mode5(x[zi],y11,zi);}
   {zugh1=x[zi];           //this is mode5 when assembly language used
    zugh1lb=zugh1>>16;     //left 16 bits of zugh1
    zugh1rb=zugh1<<16;
    zugh1rb=zugh1rb>>16;   //right 16 bits of zugh1
    rightright=zugh1rb*y2rb; //these are all 32 bits;
    rightleft=zugh1rb*y2lb;  
    leftright=zugh1lb*y2rb;
    leftleft=zugh1lb*y2lb;
    slot1=rightright+zcarry;
    if (slot1<rightright) slot3=0x00000001; else slot3=0;
    center=leftright+rightleft;
    if (center<leftright) slot3=slot3+0x00010000;
    lbofcenter=center>>16;   //break them into 16 bit lb and rb
    slot3=slot3+lbofcenter+leftleft;
    rbofcenter=center<<16;
    slot1=slot1+rbofcenter;
    if (slot1<rbofcenter) slot3=slot3+0x00000001;
    z[zi]=slot1;
    zcarry=slot3;
   }

 if (z[precp1]==0)             //no carry
   {z[precp1]=zxsignflag;
    if (y11xx<0) z[precp1]=2-z[precp1];       //Nov27,99
    return 0;
   }
 if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;    //carry
 for (zk=2;zk<precp2;zk++) z[zk-1]=z[zk];
 z[0]++;
 z[precp1]=zxsignflag;
 if (y11xx<0) z[precp1]=2-z[precp1];       //Nov27,99

 return 0;                        
}

int zmult(unsigned int *z1,unsigned int *z2)
{ int zino20;
  int precp1no20=prec+1;
  unsigned int zsign1saveno20=abs(z1[precp1no20]+z2[precp1no20]-2);
  if (*(z1+prec)==0 || *(z2+prec)==0)    //z1[prec]==0 || z2[prec]==0) 
    {*(z+prec)=0;                        //z[prec]=0;                              
     *(z+0)=0x40000000;     //z[0]=0x40000000;                       
     return 0;} 
  for (zino20=1;zino20<precp1no20;zino20++)
    {*(z11+zino20)=*(z1+zino20);   //z11[zino20]=z1[zino20];
     *(z22+zino20)=*(z2+zino20);   //z22[zino20]=z2[zino20];
    }
  *(z+0)=*(z1+0)+*(z2+0)-0x40000001;
  *(z+1)=0; 
  int precmzino20;
  for (zino20=1;zino20<prec;zino20++) 
    {precmzino20=prec-zino20;
     precp1mzkisky=precmzino20;   //'98
     zlint2=*(z22+zino20);        //(z22[zino20];
     zlint28=*(z11+precmzino20);
     mode6();  //mode6(*(z11+precmzino20)); 

     *(xp1+zino20)=zcarry;   //*(x+zino20+1)=zcarry;   //x[zino20+1]=zcarry;
     maxinmode7=zino20;     //'98
     mode77();            
    }               
  zlint2=*(z22+prec);         //z22[prec];      
  zcarry=0;
  precp1mzkisky=0;
  mode66();
  mode777();            

  if (z[precp1no20]>0)
    {if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;
     for (zino20=1;zino20<precp1no20;zino20++) *(z+zino20)=*(zp1+zino20);  
     z[0]++;
    }
  *(z+precp1no20)=zsign1saveno20;
return 0;
}

int zdivint(unsigned int *zxx1, unsigned int zkk)                                 
{ unsigned int zi,ziw;
  int zprecsave=prec;                        
  precp1a=prec+1;
  int precp2=prec+2;
  if (zxx1[prec]==0 || zkk==0)
    {z[prec]=0;
     z[precp1a]=2;
     z[0]=0x40000000;
     return 0;}
  for (ziw=1;ziw<precp2;ziw++) z11[ziw+1]=zxx1[ziw];
  unsigned int zsign=zxx1[precp1a];
  unsigned int zsaveexp=zxx1[0];
  z11[0]=zxx1[0];                       
  z11[1]=0;                        
  zkk2=zkk;
  prec++;
  precp1a=prec+1;
  z11[0]=0;
  mode8();               
  z[precp1a]=zsign; 
  z[0]=zsaveexp; 
  prec=zprecsave;
  precp1a=prec+1;
  if (z[precp1a]==0)
    {z[precp1a]=zsign;
     z[0]=z[0]-1;
     return 0;}
  if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;
  for (zi=1;zi<precp1a;zi++) z[zi]=z[zi+1];
  z[precp1a]=zsign;
  return 0;
}

int zdivint(unsigned int *zxx1,int zkkxx)    //added Nov27,99                             
{ int zkk;
  int zsignflag=2;
  unsigned int zi,ziw;
  zkk=abs(zkkxx);     
  int zprecsave=prec;                        
  precp1a=prec+1;
  int precp2=prec+2;
  if (zxx1[prec]==0 || zkk==0)
    {z[prec]=0;
     z[precp1a]=2;
     z[0]=0x40000000;
     return 0;}
  for (ziw=1;ziw<precp2;ziw++) z11[ziw+1]=zxx1[ziw];
  unsigned int zsign=zxx1[precp1a];
  unsigned int zsaveexp=zxx1[0];
  z11[0]=zxx1[0];                       
  z11[1]=0;                        
  zkk2=zkk;
  prec++;
  precp1a=prec+1;
  z11[0]=0;
  mode8();
  z[precp1a]=zsign; 
  z[0]=zsaveexp; 
  prec=zprecsave;
  precp1a=prec+1;
  if (z[precp1a]==0)
    {z[precp1a]=zsign;
     z[0]=z[0]-1;
     if (zkkxx<0) z[precp1a]=2-z[precp1a];  //sign of denominator Nov27,99
     return 0;
    }
  if (z[1]>0x7fffffff && z[2]<0xffffffff) z[2]++;
  for (zi=1;zi<precp1a;zi++) z[zi]=z[zi+1];
  z[precp1a]=zsign;
  if (zkkxx<0) z[precp1a]=2-z[precp1a];  //sign of denominator Nov27,99
  return 0;
}


int zrecip(unsigned int *zdivy)
{
   zrecall(zdivy);
   zstore(z9);
   zconinttomp(1);
   zdiv(z,z9);
   return 0;
}

int zincreaseprecision(unsigned int *z1, int zip)                     
{
   int zi;
   int zipp1=zip+1;
   for (zi=prec+zipp1;zi>=zipp1;zi--)
     {z[zi]=z1[zi-zip];}
   for (zi=zip;zi>=1;zi--)
     {z[zi]=0;}
   z[0]=z1[0];
   return 0;
}

int zdecreaseprecision(unsigned int *z1, int zip1, int zip2) 
{
   int zdel,zi,zpek;
   zdel = zip1 - zip2;
   zpek=0;
   if (z1[zdel] > 0x7fffffff)
     {if (z1[zdel+1] < 0xffffffff)
         {zpek=1;}
     }
   z[1]=z1[zdel+1] + zpek;
   for (zi=2; zi<zip2+2; zi++)
     {z[zi]=z1[zi+zdel];}
   z[0]=z1[0];
   return 0;
}

int zdiv(unsigned int *z1div, unsigned int *z2div)                         
{if (*(z1div+prec)==0 || *(z2div+prec)==0)
      {if (*(z2div+prec)==0)
        {cerr<<"divide by 0"<<'\n';}
       z[prec]=0;
       z[prec+1]=2;                       
       z[0]=0x40000000;
       return 0;                       
      }
   int zi,zk,zecx;                                              
   unsigned int zcurrent,znext;
   int zdivisorpr=1;
   int precp1=prec+1;
   int precp2=prec+2;
   unsigned int zsaveexp1=z1div[0]+0x40000000-z2div[0];
   int zsignsave1=abs(*(z1div+precp1) + *(z2div+precp1) - 2);
   for (zi=1;zi<precp1;zi++)
     {*(zrem+zi)=*(z1div+zi); 
      *(zden+zi)=*(z2div+zi); 
     }
   zdivisor=1;
   if (*(zden+prec)<0x80000000)
     {
      zdivisor=0x7fffffff/(*(zden+prec));
      *(zden+precp1)=0;               
      zcarry=0;
      zdivisorlb=zdivisor>>16;
      zdivisorrb=zdivisor<<16;
      zdivisorrb=zdivisorrb>>16;
      for (zi=1;zi<precp2;zi++)
//       {mode55(*(zden+zi),zi);}
         {zugh1=zden[zi];   //this is mode55 when assembly language used
          zugh1lb=zugh1>>16;
          zugh1rb=zugh1<<16;
          zugh1rb=zugh1rb>>16;
          leftleft=zdivisorlb*zugh1lb;
          leftright=zdivisorlb*zugh1rb;
          rightleft=zdivisorrb*zugh1lb;
          rightright=zdivisorrb*zugh1rb;
          slot1=rightright+zcarry;
          if (slot1<rightright) slot3=0x00000001; else slot3=0;
          center=leftright+rightleft;
          if (center<leftright) slot3=slot3+0x00010000;
          lbofcenter=center>>16;   //break them into 16 bit lb and rb
          slot3=slot3+lbofcenter+leftleft;
          rbofcenter=center<<16;
          slot1=slot1+rbofcenter;
          if (slot1<rbofcenter) slot3=slot3+0x00000001;
          zden[zi]=slot1;
          zcarry=slot3;
         }

      if (zden[precp1]!=0)
        {for (zk=2;zk<precp2;zk++) zden[zk-1]=zden[zk];
         zsaveexp1++;
        }
      if (zden[prec]<0x80000000)     
        {znext=0;
         for (zi=1;zi<precp1;zi++)    //this is multiply zden by 2
           {zcurrent=zden[zi];       
            zden[zi]=(zcurrent<<1)+znext;
            znext=zcurrent>>0x1f;    
           }
         zdivisor+=zdivisor;         //also multiply numerator by 2
        }
     }
   if (zden[prec]<=zrem[prec])
     {zdivisorpr=2;
      znext=0;
      for (zi=prec;zi>0;zi--)    //this is division by 2
        {zcurrent=zrem[zi];
         zrem[zi]=(zcurrent>>1)+znext;
         znext=zcurrent<<0x1f;         //31;
        }
     }

   zrem[0]=0;
   zden[0]=0;
   zden[precp1]=0;  //required for zsuplogsp
   zden[precp2]=0;
   za=zden[prec];
   int zknp1,zknm1,precmzknpr;
   for (zkn=prec;zkn>0;zkn--)
      {zknp1=zkn+1;
       zknp2=zkn+2;
       zknm1=zkn-1;
       precmzknpr=prec-zkn;
       zftemp1=zrem[zkn];
       if (zftemp1==za) zd=0xffffffff;
       else
//         {mode2(zftemp1,*(zrem+zknm1));}
         {znumerator1=zftemp1;
          znumerator2=*(zrem+zknm1);
          zdenominator=za;
          zlongdiv();
          zd=zquotient;
         }
  



       precp1mzkn=precp1-zkn;               
       precmzkn=precp1mzkn;     //'98  //first mode1
//       mode1(*(zden+precmzknpr));   //cross multiplies zd*zden to get zL

//mode1()
   zdlb=zd>>16;
   zdrb=zd<<16;
   zdrb=zdrb>>16;
   zugh1=zden[precmzknpr];
   zugh1lb=zugh1>>16;
   zugh1rb=zugh1<<16;
   zugh1rb=zugh1rb>>16;
   leftleft=zugh1lb*zdlb;
   leftright=zugh1lb*zdrb;
   rightleft=zugh1rb*zdlb;
   rightright=zugh1rb*zdrb;
   slot1=rightright+zcarry;
   if (slot1<rightright) slot3=0x00000001; else slot3=0;
   center=leftright+rightleft;
   if (center<leftright) slot3=slot3+0x00010000;
   lbofcenter=center>>16;   //break them into 16 bit lb and rb
   slot3=slot3+lbofcenter+leftleft;
   rbofcenter=center<<16;
   slot1=slot1+rbofcenter;
   if (slot1<rbofcenter) slot3=slot3+0x00000001;
   zcar=slot3;
   for (zecx=0;zecx<zkn;zecx++)
     {zugh1=zden[precp1mzkn+zecx];
      zugh1lb=zugh1>>16;
      zugh1rb=zugh1<<16;
      zugh1rb=zugh1rb>>16;
      leftleft=zugh1lb*zdlb;     //not yet calculated probably zl2=zd
      leftright=zugh1lb*zdrb;
      rightleft=zugh1rb*zdlb;
      rightright=zugh1rb*zdrb;
      slot1=rightright+zcar;
      if (slot1<rightright) slot3=0x00000001; else slot3=0;
      center=leftright+rightleft;
      if (center<leftright) slot3=slot3+0x00010000;
      lbofcenter=center>>16;   //break them into 16 bit lb and rb
      slot3=slot3+lbofcenter+leftleft;
      rbofcenter=center<<16;
      slot1=slot1+rbofcenter;
      if (slot1<rbofcenter) slot3=slot3+0x00000001;
      zL[zecx]=slot1;
      zcar=slot3;
     }




       zL[zkn]=zcar;
       zrem[zknp1]=0;     
       zL[zknp1]=0xffffffff;
       mode33();
       for (zi=0;zi<zknp2;zi++)
           {if (zrem[zi]==0xffffffff) zrem[zi]=0;
            else
              {zrem[zi]++;                   
               goto zpxpp;         
              } 
           }                    
zpxpp:
  while (zrem[zknp1]==0)
     {zd--;    
      mode3();
     }
  z[zkn]=zd;
    }             //end of zkn loop

     zftemp1=zrem[0];            //zkn=0 part
     if (zftemp1>=za) z[0]=0xffffffff;
     else
       {//mode22(zftemp1);
        mode22();
        z[0]=zugh1;}

     if (zdivisor>1)           //put zdivisor in
       {
        z[precp1]=0;
        zcarry=0;
        zdivisorlb=zdivisor>>16;
        zdivisorrb=zdivisor<<16;
        zdivisorrb=zdivisorrb>>16;
        for (zi=0;zi<precp2;zi++)     //mode56
//            {mode56(z[zi],zi);}

            {zugh1=z[zi];
             zugh1lb=zugh1>>16;
             zugh1rb=zugh1<<16;
             zugh1rb=zugh1rb>>16;
             leftleft=zdivisorlb*zugh1lb;
             leftright=zdivisorlb*zugh1rb;
             rightleft=zdivisorrb*zugh1lb;
             rightright=zdivisorrb*zugh1rb;
             slot1=rightright+zcarry;
             if (slot1<rightright) slot3=0x00000001; else slot3=0;
             center=leftright+rightleft;
             if (center<leftright) slot3=slot3+0x00010000;
             lbofcenter=center>>16;   //break them into 16 bit lb and rb
             slot3=slot3+lbofcenter+leftleft;
             rbofcenter=center<<16;
             slot1=slot1+rbofcenter;
             if (slot1<rbofcenter) slot3=slot3+0x00000001;
             z[zi]=slot1;
             zcarry=slot3;
            }
            
        if (z[precp1]!=0)
          {modex();
           zsaveexp1++;
          }
       }

     if (zdivisorpr==2)
       {
        z[precp1]=0;
        zcarry=0;
        zdivisor=zdivisorpr;
        zdivisorlb=zdivisor>>16;
        zdivisorrb=zdivisor<<16;
        zdivisorrb=zdivisorrb>>16;
        for (zi=0;zi<precp2;zi++)         //mode56?
//          {mode56(z[zi],zi);}

            {zugh1=z[zi];
             zugh1lb=zugh1>>16;
             zugh1rb=zugh1<<16;
             zugh1rb=zugh1rb>>16;
             leftleft=zdivisorlb*zugh1lb;
             leftright=zdivisorlb*zugh1rb;
             rightleft=zdivisorrb*zugh1lb;
             rightright=zdivisorrb*zugh1rb;
             slot1=rightright+zcarry;
             if (slot1<rightright) slot3=0x00000001; else slot3=0;
             center=leftright+rightleft;
             if (center<leftright) slot3=slot3+0x00010000;
             lbofcenter=center>>16;   //break them into 16 bit lb and rb
             slot3=slot3+lbofcenter+leftleft;
             rbofcenter=center<<16;
             slot1=slot1+rbofcenter;
             if (slot1<rbofcenter) slot3=slot3+0x00000001;
             z[zi]=slot1;
             zcarry=slot3;
            }

        if (z[precp1]!=0)
          {modex();
           zsaveexp1++;
          }
       }
   if (z[1]<0xffffffff && z[0]>0x7fffffff) z[1]++;   //round
   z[0]=zsaveexp1;   
   z[precp1]=zsignsave1;

   if(z[prec]==0)  //finally, guard against 0000 ffff ffff ffff
     {for (zi=prec;zi>1;zi--) z[zi]=z[zi-1];
      z[0]=z[0]-1;}

return 0; 
} 


int zabs(unsigned int *z1)
{  zrecall(z1);
   zstore(z9);
   z9[prec+1]=2;
   zrecall(z9);
   return 0;
}

int zsqrt(unsigned int *zz1)
{
   int ziw,zprecinitialsave,zprecsave,zendflag;
   int zcountpowers;
   float zfguess;
   if (zz1[prec+1]==0)
      {zmessage="square root of negative--proceed with abs value";
       zbreak();}
   for (ziw=1;ziw<prec+1;ziw++)
      {zz11[ziw+1]=zz1[ziw];}
   zz11[prec+2]=2; 
   zz11[1]=0;
   zz11[0]=zz1[0];
   zprecinitialsave=prec;
   prec=prec+1;
   zprecsave=prec;                  
   zcountpowers=0;

if (zz11[0]>0x40000000)
  {zcountpowers=zz11[0]-0x40000000;
   zcountpowers=zcountpowers>>1;   //get even part
   zcountpowers=zcountpowers<<1;
   zz11[0]=zz11[0]-zcountpowers;
  }

if (zz11[0]<0x40000000)
  {zcountpowers=0x40000000-zz11[0];
   zcountpowers=zcountpowers>>1;  //get even part
   zcountpowers=zcountpowers<<1;
   zcountpowers=-zcountpowers;
   zz11[0]=zz11[0]-zcountpowers;
  }
   zconmptof(zz11);
   zfguess=sqrt(zf);
   prec=3;
   zff=zfguess;
   zconftomp(zff);
   zincreaseprecision(z,1);      
   prec=4;
   zendflag=0;
zbombaypr:
   for (ziw=0;ziw<prec+2;ziw++) 
     {zz22[ziw]=z[ziw];}
   zdecreaseprecision(zz11,zprecsave,prec);
   zdiv(z,zz22);         //somehow this failed
   zadd(zz22,z);
   zdivint(z,2);
   if (2*prec>zprecsave)
     {goto zbombay2pr;}
   zincreaseprecision(z,prec);
   prec=2*prec;
   goto zbombaypr;
zbombay2pr:
   if (zendflag==2)
     {goto zbombay3pr;}
    zendflag++;
    zincreaseprecision(z,zprecsave-prec);
    prec=zprecsave;
    goto zbombaypr;
zbombay3pr:
    if (z[1]>0x7fffffff)
      {if (z[2]<0xffffffff)
         {z[2]++;}
      }
    prec=zprecinitialsave;
    for (ziw=1;ziw<prec+1;ziw++)
      {z[ziw]=z[ziw+1];}
    z[prec+1]=2;
    z[0]=z[0]+(zcountpowers>>1); 
    return 0;
}

int zconftomp(double zff)                                      
{                                       //this gets it to base 10^4
   int ziw,zsignflag,zp;                     
   long zi;                                  
   double zf1,zf2,zf3,zfdtenth,zfdten;
   for (ziw=0;ziw<prec+2;ziw++)
      {z[ziw]=0;}
   zfdtenth=1.0e8;
   zfdten=10L;
   zf1=0L;
   zf1=zff;
   if (zf1==0)
       {for (ziw=0;ziw<prec+1;ziw++)
          {z[ziw]=0;}
        z[prec+1]=2;
        goto zbnar;
       }
   zsignflag=2;
   if (zf1<0)
     {zsignflag=0;
      zf1=-zf1;}
   zf2=log(zf1)/2.3025850929940457;
   zp=zf2;
   if (zp>0)
     {for (zi=1;zi<zp+1;zi++)
       zf1=zf1/zfdten;}
   if (zp<0)
     {for (zi=1;zi<abs(zp)+1;zi++)
       zf1=zf1*zfdten;}
zbgjh:
   zi=zp/8;    
   zi=8*zi;
   if (zi==zp)
     {zp=zp/8;
      goto zuhn;}
   zp++;
   zf1=zf1/zfdten;
   goto zbgjh;
zuhn:
   zf3=zf1*zfdtenth;
   zi=zf3-1;
   if (zi>=0xffffffff)
      {zp++;
       zf3=zf3/zfdtenth;
       zf1=zf1/zfdtenth;}
   if (zf3<1)
      {zp=zp-1;
       zf3=zf3*zfdtenth;
       zf1=zf1*zfdtenth;}
   z[prec]=zf3;
   zf3=z[prec];
   zf1=zf1*zfdtenth-zf3;
   zf1=zf1*zfdtenth;
   zi=zf1;
   z[prec-1]=zi;
   if (prec==2)
     {goto zuny;}
   zf2=zi;
   for (ziw=1;ziw<prec-2;ziw++)
     {z[ziw]=0;}
zuny:
   z[prec+1]=zsignflag;
   z[0]=zp+0x40000000;
zcontobase32(z);
zbnar: 
   return 0;
}
                                  //converts a number in base 10000 to ffff
int zcontobase32(unsigned int *zz4)                    
{  int ziw,ziwpr,zsignflick,zpower;       
   zpower=zz4[0]-0x40000000;
   for (ziw=0;ziw<prec+2;ziw++) zz111[ziw]=zz4[ziw];
   for (ziw=1;ziw<prec+1;ziw++) z[ziw]=0;
   for (ziw=1;ziw<prec+1;ziw++) zconfac[ziw]=0;
   z[prec+1]=2;
   z[0]=0x40000001;
   zconfac[prec+1]=2;
   zconfac[prec]=100000000;
   zconfac[0]=0x40000001;  
   zsignflick=2;
   if (zz111[prec+1]==0) zsignflick=0;
   for (ziw=1;ziw<prec+1;ziw++)
     {for (ziwpr=1;ziwpr<prec+2;ziwpr++) zz3[ziwpr]=0;
      zz3[prec+1]=2;
      zz3[prec]=zz111[ziw];
      zz3[0]=0x40000001;
      zadd(z,zz3);
      zdiv(z,zconfac);
     }
  for (ziwpr=0;ziwpr<prec+2;ziwpr++) zz3[ziwpr]=z[ziwpr];
  zxtonth(zconfac,zpower);   //(10^8)^power
  zmult(z,zz3);
  z[prec+1]=zsignflick;
  return 0;
}

int zxtonth(unsigned int *zzz1,int zip)                         //46
{  int zi,zn,zsignflagg;
   for (zi=0;zi<prec+2;zi++)
     {zzz3[zi]=zzz1[zi];}
   zn=zip;
   zsignflagg=0;
   if (zn<0)
     {zsignflagg=1;
      zn=-zn;}
   if (zn==0)
     {for (zi=1;zi<prec;zi++)
       {z[zi]=0;}
      z[prec+1]=2;
      z[prec]=1;
      z[0]=0x40000001;
      goto zrtnzxt1;
     }
   zconinttomp(1);
   zstore(zzz2);
zbackzxt:
   zi=zn>>1;
   zi=zi<<1;
   if (zi==zn)
     {zn=zn>>1;
      zmult(zzz3,zzz3);
      zstore(zzz3);
      goto zbackzxt;
     }
   zmult(zzz3,zzz2);
   zstore(zzz2);
   zn=(zn-1)>>1;
   if (zn==0) goto zrtnzxt;
   zi=2*zi;
   zmult(zzz3,zzz3);
   zstore(zzz3);
   goto zbackzxt;
zrtnzxt:
   if (zsignflagg==1)
     {zconinttomp(1);
      zdiv(z,zzz2);
      zstore(zzz2);
     }
   zrecall(zzz2);
zrtnzxt1:
   return 0;
}

int zconmptof(unsigned int *z1)                                  //30
{  int zngisflag;
   float zf1,zf2,zf3,zi;
   int zp;
   zngisflag=1;
   if (z1[prec+1]==0)
     {zngisflag=-1;}
   if (z1[prec]==0)
     {zf=0;
      goto zuut2;}
   zf1=z1[prec];
   zf2=z1[prec-1];
   zf3=z1[prec-2];
   zf=zf1+(zf2+zf3/zftenth)/zftenth;
   zp=z1[0]-0x40000001;
   if (zp==0)
     {goto zuut;}
   if (zp>0)
      {for (zi=1;zi<zp+1;zi++)
         {zf=zf*zftenth;}
       goto zuut;
      }
    zp=-zp;
    for (zi=1;zi<zp+1;zi++)
       {zf=zf/zftenth;}
zuut: if (zngisflag==-1)
        {zf=-zf;}
zuut2:  return 0;
}

int zsuppi()                                            //22
//this evaluates pi from Euler's expression:
//     pi=20*arctan(1/7) + 8*arctan(3/79)
//and Euler's expression for arctan
//   arctan(x)=(y/x)*(1 + (2/3)*y + (2*4/3*5)*y^2 + (2*4*6/3*5*7)*y^3 + ...)
// where
//               y=x^2/(1+x^2)
//The success of this calculation depends on the facts that y=2/100 when
//x=1/7 and y=144/100000 when x=3/79. See a history of the subject for details.

{  int zi,znprec,zn,zn1,zprecsave2;
   for (zi=0; zi<zsuperprec+1; zi++)
     {z1[zi]=0;}
   zprecsave2=prec;
   prec=zsuperprec;
   zsetzone();
   zzero(ze);
   ze[prec]=1;
   znprec=32*log(2)*prec/log(50);
   for (zn=znprec;zn>=1;zn--)
     {zn1=2*zn+1;
      zdivint(ze,0x19);
      zdivint(z,zn1);
      zmultint(z,zn);
      zadd(z,zone);
      zstore(ze);
     }
   zmultint(ze,7);
   zdivint(z,0x32);
   zmultint(z,0x14);
   zstore(z1);
                        //part 2
   zzero(ze);
   ze[prec]=1;
   znprec=32*log(2)*prec/log(695);  
   for (zn=znprec;zn>=1;zn--)
     {zn1=2*zn+1;
      zdivint(ze,10000);
      zdivint(z,5);     
      zmultint(z,144);
      zdivint(z,zn1);
      zmultint(z,zn);
      zadd(z,zone);
      zstore(ze);
     }
   zmultint(z,0x18);
   zmultint(z,0x4f);
   zdivint(z,10000);      
   zdivint(z,5);
   zmultint(z,8);
   zadd(z,z1);
   zstore(zsuperpi);
   prec=zprecsave2;
   return 0;
}

int zsetzone()                                            //2            
{
  int zi;
  for (zi=1;zi<prec;zi++)
    {zone[zi]=0;}
  zone[prec]=1;
  zone[prec+1]=2;
  zone[0]=0x40000001;
  return 0;
}

int zzero(unsigned int *z1)                                    //19      
{
   int zi,precp1;
   precp1=prec+1;
   for (zi=1;zi<precp1;zi++)
     {z1[zi]=0;}
   z1[0]=0x40000001;
   z1[precp1]=2;
   return 0;
}

int zpi()                                             //24
{  zdecreaseprecision(zsuperpi,zsuperprec,prec);
   return 0;
}

int zfracpart(unsigned int *zz2)                                 //25
{                                      
   int zi,zshift,zox;                     
   for (zi=0; zi<prec+1; zi++)        
     {z10[zi]=zz2[zi];}               
   zshift=z10[0]-0x40000000; 
   if ((prec-zshift)<1)
     {for (zi=1;zi<prec+1;zi++)
        {z[zi]=0;}
      z[0]=0x40000001;
      z[prec+1]=2;
      goto zplob;
     }
   z[0]=0x40000000;
   zox=z10[0]-0x40000000;
   if (zox<1)
     {zshift=0;
      z[0]=z10[0];}
   for (zi=prec - zshift; zi>=1 ; zi--)
     {z[zi+zshift]=z10[zi];}
   for (zi=zshift;zi>=1;zi--)
     {z[zi]=0;}
   z[prec+1]=zz2[prec+1];
zplob:
   return 0;
}

int zcos(unsigned int *zz3)                                      //26
{                                             
   int zi,ziw,zsignflag1,zprecsave9;
   for (ziw=1;ziw<prec+2;ziw++)
    {zz11[ziw+1]=zz3[ziw];}
   zz11[1]=0;
   zz11[0]=zz3[0];
   for (ziw=1;ziw<prec+1;ziw++)
     {z[ziw+1]=0;}
   z[prec+2]=2;
   z[0]=0x40000001;
   zprecsave9=prec;
   prec++;
   zpi();
   zdiv(zz11,z);
   zdivint(z,2);
   zfracpart(z);
   zmultint(z,2);    
   for (ziw=0;ziw<prec+2;ziw++)
     {zz11[ziw]=z[ziw];}
   zpi();
   zmult(zz11,z);    //(zz11 mod 2pi)
   for (ziw=0;ziw<prec+2;ziw++)
     {zz11[ziw]=z[ziw];}
   zsignflag1=2;
   zpi();             //reduce to first quadrant
   zmultint(z,3);
   zdivint(z,2);
   zsub(z,zz11);
   if (z[prec+1]==0 || z[prec]==0)
      {zpi();
       zmultint(z,2);
       zsub(z,zz11);
       zstore(zz11);
       goto zproko2;
      }
   zpi();
   zsub(z,zz11);
   if (z[prec+1]==0 || z[prec]==0)
      {
       zpi();
       zsub(zz11,z);
       zstore(zz11);
       zsignflag1=0;
       goto zproko2;
      }
   zpi();
   zdivint(z,2);
   zsub(z,zz11);
   if (z[prec+1]==0 || z[prec]==0)
     {zpi();
      zsub(z,zz11);
      zstore(zz11);
      zsignflag1=0;
      goto zproko2;
     }
zproko2:
   zpi();
   zdivint(z,4);
   zsub(zz11,z);
   if (z[prec+1]==2 || z[prec]==0)
     {zpi();
      zdivint(z,2);
      zsub(z,zz11);
      zsinmajor(z);
      goto zproko4;
     }
   zcosmajor(zz11);

zproko4:
   if (z[1]>0x7fffffff)
     {if(z[2]<0xffffffff)
        {z[2]++;}
     }
   prec = zprecsave9;
   for (zi=1;zi<prec+2;zi++)
      {z[zi]=z[zi+1];}
   z[prec+1]=abs(zsignflag1+z[prec+1]-2);
   return 0;
}

int zsin(unsigned int *zz4)                                      //27
{                                               
   int zi,ziw,zsignflag,zsignflag1,zprecsave2;
   for (ziw=1;ziw<prec+2;ziw++) 
      {zz11[ziw+1]=zz4[ziw];}
   zz11[1]=0;
   zz11[0]=zz4[0];
   zprecsave2=prec;
   prec++;
   zsignflag=2;
   if (zz11[prec+1]==0) 
     {zsignflag=0;
      zz11[prec+1]=2;}
   zpi(); 
   zmultint(z,2);
   zsub(z,zz11);
   if (z[prec+1]==2)
     {goto zblith;}
   zpi();
   zdiv(zz11,z);
   zdivint(z,2);
   zfracpart(z);
   zmultint(z,2);
   zstore(zz11);
   zpi();
   zmult(zz11,z);
   zstore(zz11);
zblith: zrecall(zz11);
   zsignflag1=2;
   zpi();
   zmultint(z,3);
   zdivint(z,2);
   zsub(z,zz11);
   if (z[prec+1]==0 || z[prec]==0)
      {zpi();
       zmultint(z,2);
       zsub(z,zz11);
       zstore(zz11);
       zsignflag1=0;
       goto zproko;
      }
   zpi();                             
   zsub(z,zz11);
   if (z[prec+1]==0 || z[prec]==0)
      {zpi();
       zsub(zz11,z);
       zstore(zz11);
       zsignflag1=0;
       goto zproko;
      }
   zpi();
   zdivint(z,2);
   zsub(z,zz11);
   if (z[prec+1]==0 || z[prec]==0)
      {zpi();
       zsub(z,zz11);
       zstore(zz11);
       goto zproko;
      }
zproko:
   zpi();
   zdivint(z,4);
   zsub(zz11,z);
   if (z[prec+1]==2)
      {zpi();
       zdivint(z,2);
       zsub(z,zz11);
       zcosmajor(z);
       goto zproko3;
      }
   zsinmajor(zz11);
zproko3:
   if (z[1]>0x7fffffff)
      {if (z[2]<0xffffffff)
         {z[2]++;}
      }
   prec=zprecsave2; 
   for (zi=1;zi<prec+2;zi++)
      {z[zi]=z[zi+1];}
   zi=zsignflag+zsignflag1+z[prec+1];
   if (zi>3) z[prec+1]=zi-4;
   if (zi<3) z[prec+1]=zi;
   return 0;
}

int zcosmajor(unsigned int *zz22)                                //28
{int ziw;

  for (ziw=0;ziw<prec+2;ziw++)
    {zz44[ziw]=zz22[ziw];}
  zdivint(zz44,2);  
  zsinmajor(z);
  zmult(z,z);
  zmultint(z,2);
  zsetzone();
  zsub(zone,z);
  return 0;
}

int zsinmajor(unsigned int *zz33)                                 //29
{int ziw,zkm,zzi,zzim;
   zrecall(zz33);
   zstore(zz55);
   zdivint(zz55,3);
   zstore(z10);
   zstore(zz55);
   zsetzone();
   if (zz55[prec]==0)
      {znum=1;
       goto zahabbul;}
   ziw=zz55[0]-0x40000000;
   if (ziw<-prec/3)           
      {znum=1;
       goto zahabbul;}
   if (zz55[0]<0x3fffffff)
     {znum=4*precision/18 + 1;  //these guards against float underflows
      goto zahabbul;}           //the exp could have been done similarly
   zconmptof(zz55);
   znterms(zf);
zahabbul:
   zmult(zz55,zz55);
   zz55[prec+1]=2-z[prec+1];
   for (zkm=0;zkm<prec+1;zkm++) 
      {zz55[zkm]=z[zkm];}
   zrecall(zone);
   zstore(ze);
   for (zzi=znum;zzi>=3;zzi=zzi-2)
     {zdivint(ze,zzi);
      zzim=zzi-1;
      zdivint(z,zzim);
      zmult(z,zz55);
      zadd(zone,z);
      zstore(ze);
     }
   zmult(z10,ze);
   zstore(ze);
   zmultint(ze,3);
   zstore(zz55);
   zmult(ze,ze);
   zmult(z,ze);
   zmultint(z,4);
   zsub(zz55,z);
   return 0;
}

int znterms(float zf)                              //31        
{
  float zfa,zfb,zfc;
  int zhalf;
  zfa=zf;                 
  if (zfa==0)
    {znum=3;
     goto zwhatamess;}
  if (zfa<0)
    {zfa=-zfa;}
  zfc=32*log(2)*prec/(2.7182818*zfa);   //zfa small makes this large
  zfb=1+zfc/(1+log(1+zfc/2));           //so this will be large
  zfb=zfa*2.7182818*(zfb+zfc)/(1+log(zfb));
  znum=zfb;
  zhalf=znum/2;
  if (znum==2*zhalf)
    {znum++;}
zwhatamess:
  return 0;
}

int zarcsin(unsigned int *zzz1)                                //35    
{  int zi,zsignflag,zendflag,zprecsave55;               
   float zfguess;                                  
   double zffguess;
   for (zi=0;zi<prec+2;zi++)
     {zzz25[zi]=zzz1[zi];}
   zsetzone();
   zsignflag=2;
   if (zzz25[prec+1]==0)
     {zsignflag=0;
      zzz25[prec+1]=2;}
   zprecsave55=prec;
   zmult(zzz25,zzz25);                     
   zsub(zone,z);
   zsqrt(z);                             
   zadd(zone,z);                         
   zadd(z,z);                            
   zsqrt(z);                             
   zdiv(zzz25,z);                         
   zstore(zzz25);
   zconmptof(zzz25);
   zfguess=zf/sqrt(1-zf*zf);      
   zfguess=atan(zfguess);
   zffguess=zfguess;
   prec=1;
   zendflag=0;
   zconftomp(zffguess);
   if (2>zprecsave55)
     {goto zbombay2prpr;}
   zincreaseprecision(z,1);
   prec=2;
zbombayprpr:
   zstore(zzz3);
   zdecreaseprecision(zzz25,zprecsave55,prec);
   zstore(zzz4);
   zsinmajor(zzz3);
   zstore(zzz5);
   zsub(zzz4,zzz5);
   zstore(zzz5);
   zcosmajor(zzz3);
   zdiv(zzz5,z);
   zadd(z,zzz3);
   if (2*prec>zprecsave55)
     {goto zbombay2prpr;}
   zincreaseprecision(z,prec);
   prec=2*prec;
   goto zbombayprpr;
zbombay2prpr:
   if (zendflag==1)
     {goto zbombay3prpr;}
   zincreaseprecision(z,zprecsave55-prec);
   prec=zprecsave55;
   zendflag=1;
   goto zbombayprpr;
zbombay3prpr:
   zadd(z,z);
   z[prec+1]=zsignflag;
   return 0;
}

int zsupe()                                          //36 
{
  int zkm,niteremax,zzi,zprecsave7;
  zprecsave7=prec;
  prec=zsuperprec;
  zsetzone();
  for (zkm=0;zkm<prec+1;zkm++)
     {zsupere[zkm]=zone[zkm];}
  zf=1;
  znterms(zf);
  niteremax=znum;
  for (zzi=niteremax;zzi>=1;zzi--)
    {zdivint(zsupere,zzi);
     zadd(z,zone);
     zstore(zsupere);}
  prec=zprecsave7;

  return 0;
}

int zee()                                                     //37
{ zdecreaseprecision(zsupere,zsuperprec,prec);
  return 0;
}

int zexpfcnmajor(unsigned int *zz33)                                //41
{                                   
  int zi,zniteremax,zsignflag23;
  zrecall(zz33);
  zstore(zz55);
  zsetzone();
  if (zz55[prec]==0)
     {zniteremax=1;
      goto zucc;}
  zsignflag23=2;
  if (zz55[prec+1]==0)
     {zsignflag23=0;
      zz55[prec+1]=2;
     }
  zrecall(zone);
  zstore(ze);
  zconmptof(zz55);    //on the float scale this can be zero.
  if (zz55[0]<0x3fffffff)
     {znum=4*precision/18 + 1;  //these guard against float underflows
      goto zxvvvw;}   
  znterms(zf);        
zxvvvw:
  zniteremax=znum;    
  if (zniteremax==0)
    {zniteremax=1;}
zucc:
  for (zi=zniteremax;zi>=1;zi--)
    {zdivint(ze,zi);
     zmult(z,zz55);
     zadd(zone,z);
     zstore(ze);
    }
  if (zsignflag23==0)
    {zrecall(zone);
     zdiv(zone,ze);
     zstore(ze);
    }
  zrecall(ze);
  zstore(z);
  return 0;
}

int zexp(unsigned int *zz4)                                        //42         
{                                            
   int ziw,zprecsave335,zsave00,zsignflag555;
   zsetzone();
   for (ziw=1;ziw<prec+2;ziw++)
     {zz11[ziw+1]=zz4[ziw];}
   zz11[1]=0;
   zz11[0]=zz4[0];
   zprecsave335=prec;
   prec++;
   zsetzone();
   zsave00=0;
   zsignflag555=0;
   if (zz11[prec+1]==0)
      {zsignflag555=1;
       zz11[prec+1]=2;}
   zlogsp2();
   zmultint(z,4);
   zdiv(zz11,z);
   zintpart(z);
   zsave00=zr;
   zfracpart(z);
   zstore(zzz5);
   zlogsp2();
   zmultint(z,4);
   zmult(z,zzz5);
   zstore(zz11);
   zexpfcnmajor(zz11);
   if (zsave00==-1) 
     {zsave00=536870912;
      goto ztuth;}
   ziw=zsave00/8;
   ziw=8*ziw;
   if (ziw==zsave00)
     {zsave00=zsave00/8;
      goto ztuth;}
   zsave00=(zsave00-1);
   ziw=zsave00/8;
   ziw=8*ziw;
   if (ziw==zsave00)
      {zsave00=zsave00/8;
       zmultint(z,16);
       goto ztuth;}
   zsave00=zsave00-1;
   ziw=zsave00/8;
   ziw=8*ziw;
   if (ziw==zsave00)
      {zsave00=zsave00/8;
       zmultint(z,0x100);
       goto ztuth;}
   zsave00=zsave00-1;
   ziw=zsave00/8;
   ziw=8*ziw;
   if (ziw==zsave00)
      {zsave00=zsave00/8;
       zmultint(z,0x1000);
       goto ztuth;}
   zsave00=zsave00-1;
   ziw=zsave00/8;
   ziw=8*ziw;
   if (ziw==zsave00)
      {zsave00=zsave00/8;
       zmultint(z,0x10000);
       goto ztuth;}
   zsave00=zsave00-1;
   ziw=zsave00/8;
   ziw=8*ziw;
   if (ziw==zsave00)
      {zsave00=zsave00/8;
       zmultint(z,1048576);
       goto ztuth;}
   zsave00=zsave00-1;
   ziw=zsave00/8;
   ziw=8*ziw;
   if (ziw==zsave00)
      {zsave00=zsave00/8;
       zmultint(z,16777216);
       goto ztuth;}
   zsave00=zsave00-1;
   ziw=zsave00/8;
   ziw=8*ziw;
   if (ziw==zsave00)
      {zsave00=zsave00/8;
       zmultint(z,268438456);
       goto ztuth;}
   zmessage="error in expfcn";
   zbreak();
ztuth:
   z[0]=z[0]+zsave00;
   if (zsignflag555==1)
      {zdiv(zone,z);}
   if (z[1]>0x7fffffff) 
     {if (z[2]<0xffffffff)
        {z[2]++;}
     }
   prec=zprecsave335;
   for (ziw=1;ziw<prec+2;ziw++)
     {z[ziw]=z[ziw+1];}
   return 0;
}

int zlogsp2()
{
  zdecreaseprecision(zsuperlogsp2,zsuperprec,prec);
  return 0;
}

int zintpart(unsigned int *z1)                                   //43
{                      
   if (z1[0]<0x40000001) 
      {zr=0;}
   if (z1[0]>0x40000001)
      {zr=-1;}
   if (z1[0]==0x40000001)
      {zr=z1[prec];}
   return 0;
}

int zsuplogsp()             //computes log base e of 2
{
  int zprecsave22;
  zprecsave22=prec;
  prec=zsuperprec;
  zzero(zz22);
  zz22[prec]=2;
  zz22[0]=0x40000001;
  zlogmajor(zz22);
  zstore(zsuperlogsp2);
  prec=zprecsave22;
  return 0;
}

int zlogmajor(unsigned int *zz22)                                    //40      
{ int zi,ziw,zprecsave11,zsave0,zendflag;         
  for (zi=0;zi<prec+2;zi++)
     {zz44[zi]=zz22[zi];}
  zprecsave11=prec;
  zee();
  zstore(zzz1);
  zsave0=0;
zpete: 
  zsub(zz44,zzz1);
  if (z[prec+1]==2 || z[prec]==0)
     {zsave0++;
      zdiv(zz44,zzz1);
      zstore(zz44);
      goto zpete;}
  zsqrt(zz44);
  zsqrt(z);             
  zsqrt(z);             
  zsqrt(z);
  zstore(zzz2);
  if (zzz2[prec+1]==0)
    {cerr<<"log of negative number in zlogmajor"<<'\n';}
  if (zzz2[prec]==0)
    {cerr<<"log of zero in zlogmajor"<<'\n';}
  if (zzz2[0]>0x40000004)
    {cerr<<"argument of log may be out of float range (large)"<<'\n';}
  if (zzz2[0]<0x40000000-4)
    {cerr<<"argument of log may be out of float range (small)"<<'\n';}
  zconmptof(zzz2);
  zff=zf;
  prec=1; 
  zff=log(zff);
  zconftomp(zff);
  zincreaseprecision(z,1);
  prec=2;                                
  zendflag=0;
zbombay:
  zstore(zz44);
  zdecreaseprecision(zzz2,zprecsave11,prec);
  zstore(zzz1);
  zexpfcnmajor(zz44);   
  zstore(zzz3);
  zsub(zzz1,zzz3);
  zdiv(z,zzz3);
  zadd(z,zz44);
  if (2*prec>zprecsave11)
     {goto zbombay2;}
  zincreaseprecision(z,prec);
  prec=2*prec;
  goto zbombay;
zbombay2:
  if (zendflag==2)
     {goto zbombay3;}
  zendflag++;
  zincreaseprecision(z,zprecsave11-prec);
  prec=zprecsave11;
  goto zbombay;
zbombay3:
  zmultint(z,16);   
  zstore(zz44);
  zconinttomp(zsave0);
  zadd(z,zz44);
  return 0;
}

int zlog(unsigned int *zz3)                                         //44 
{  int zi,ziw,zsignflaglog,zsave0,zprecsave27;
   for (zi=1;zi<prec+2;zi++)               
      {zz11[zi+1]=zz3[zi];}
   zz11[0]=zz3[0];
   zz11[1]=0;
   zprecsave27=prec;
   prec++;
   zsetzone();
   if (zz11[prec+1]==0 || zz11[prec]==0)
     {zmessage="log of negative or 0";
      zbreak();
     }
   zsignflaglog=2;
   if (zz11[0]<0x40000001)  
      {zsignflaglog=0;
       zdiv(zone,zz11);
       zstore(zz11);
      }
   zsave0=8*(zz11[0]-0x40000000)-4; 
   if (zsave0<0)
     {zmessage="error in zlog";
      zbreak();}
   zlogsp2();
   zmultint(z,4);    
   zmultint(z,zsave0);
   zstore(zzz5);
   zz11[0]=0x40000000;
   zmultint(zz11,65536);
   zstore(zz11);        
   zlogmajor(zz11);    
   zadd(z,zzz5);
   z[prec+1]=zsignflaglog;                 
   if (z[1]>0x7fffffff)
     {if (z[2]<0xffffffff)
        {z[2]++;}
     }
   prec=zprecsave27;
   for (ziw=1;ziw<prec+2;ziw++)             
     {z[ziw]=z[ziw+1];}
   return 0;
}

int zarctan(unsigned int *zz5)                                   //45
{int zi,zspecify;
 zspecify=0;
   zrecall(zz5); 
   zstore(zzz1);
if (zzz1[0]>=0x40000000)
 {if (zzz1[prec]>0)
  {zspecify=1;
   zconinttomp(1);
   zdiv(z,zzz1);
   zstore(zzz1);
   }
 }
   zmult(zzz1,zzz1);
   zstore(zzz2);
   zconinttomp(1);
   zadd(z,zzz2);
   zsqrt(z);
   zdiv(zzz1,z);
   zarcsin(z);
   zstore(zzz2);
   if (zspecify==1)
     {zpi();
      zdivint(z,2);
      zstore(zzz1);
      if (zzz2[prec+1]==2) 
        {zsub(zzz1,zzz2);
         zstore(zzz2);}
      if (zzz2[prec+1]==0)
        {zadd(zzz1,zzz2);
         zchs(z);
         zstore(zzz2);}
     }
   zrecall(zzz2);
   return 0;
}

int zconinputtomp(unsigned int *zinput)
{int zi;
 for (zi=0;zi<precision+2;zi++) zinpu[zi]=zinput[zi];
 zzero(zzp3); 
 for (zi=1;zi<precision+1;zi++) 
  {zconinttomp(zinpu[zi]);
   zadd(z,zzp3);
   zdivint(z,10000);
   zstore(zzp3);}
 zconinttomp(10);
 zxtonth(z,zinpu[0]);
 zmult(zzp3,z);
 if (zinput[precision+1]==0) zchs(z);
 return 0;
}