extern int solvpoly(int ynpoly,unsigned int * *yapoly);   //need this
extern int yfindmax();                                 //except for this one
extern int ydivideout1();                              //and one marked below
extern int ymeshpatch();                               //no others are needed
extern int ydivideoutcomplex();
extern int yrealroot();
extern int ysaveistep();
extern int ysaveistep2();
extern int yrecoveristep();
extern int yrecoveristep2();
extern int ytestroot();
extern int ywhateverf();
extern int yiterate();                                  
extern int yiterate2(int yniter2);
extern int yfunc();
extern int ydfdx();
extern int yr0();
extern int yiterq();
extern int yoriglq();
extern int polydeclarations();   
extern int multpolys(int yn1in,unsigned int * *ypoly1in,int yn2in,unsigned int * *ypoly2in);
extern int multiplyout();                                     //need this
extern int yrealroot2();
extern int yqw();
extern int ydqw();
extern int yqwdqw();
extern int yr0dr0();
extern int yiterdq();                               
extern int yorigldq();

int yniter2;
int ynten1=500;
int ynitermax,yp;
int yn2,yi,yiabs,yj,yk,ynpasses;
unsigned int yn1in,yn2in;
int ynisnow,ynpassq,ymessage2,ymessage;
int yimax,ynpassq2,ymessagesave5;
int ymessagesave55;
unsigned int yimportant;
unsigned int yimaximportant;
int yerrorflag;      
int ynpoly;

realscalar yxoldmax_ram;unsigned int *yxoldmax=yxoldmax_ram.s;   
realscalar yxmax_ram;unsigned int *yxmax=yxmax_ram.s;            
realscalar yxmaxmax_ram;unsigned int *yxmaxmax=yxmaxmax_ram.s;   
realscalar yxleft_ram;unsigned int *yxleft=yxleft_ram.s;         
realscalar yfmax_ram;unsigned int *yfmax=yfmax_ram.s;            
realscalar yxlower_ram;unsigned int *yxlower=yxlower_ram.s;      
realscalar yx_ram;unsigned int *yx=yx_ram.s;                     
realscalar yw_ram;unsigned int *yw=yw_ram.s;                     
realscalar yu2_ram;unsigned int *yu2=yu2_ram.s;                  
realscalar ywlower_ram;unsigned int *ywlower=ywlower_ram.s;
realscalar ydel_ram;unsigned int *ydel=ydel_ram.s;                        
realscalar yf_ram;unsigned int *yf=yf_ram.s;                              
realscalar yf1_ram;unsigned int *yf1=yf1_ram.s;                           
realscalar yf1prev_ram;unsigned int *yf1prev=yf1prev_ram.s;               
realscalar yfprev_ram;unsigned int *yfprev=yfprev_ram.s;                  
realscalar yfsave5_ram;unsigned int *yfsave5=yfsave5_ram.s;               
realscalar yf1save5_ram;unsigned int *yf1save5=yf1save5_ram.s;            
realscalar yfprevsave5_ram;unsigned int *yfprevsave5=yfprevsave5_ram.s;    
realscalar yf1prevsave5_ram;unsigned int *yf1prevsave5=yf1prevsave5_ram.s;  
realscalar yfsave55_ram;unsigned int *yfsave55=yfsave55_ram.s;              
realscalar yf1save55_ram;unsigned int *yf1save55=yf1save55_ram.s;           
realscalar yfprevsave55_ram;unsigned int *yfprevsave55=yfprevsave55_ram.s;  
realscalar yf1prevsave55_ram;unsigned int *yf1prevsave55=yf1prevsave55_ram.s; 
realscalar yxprev_ram;unsigned int *yxprev=yxprev_ram.s;          
realscalar yx2save_ram;unsigned int *yx2save=yx2save_ram.s;       
realscalar y1D16_ram;unsigned int *y1D16=y1D16_ram.s;             
realscalar y1Dm5_ram;unsigned int *y1Dm5=y1Dm5_ram.s;             
realscalar ytemp_ram;unsigned int *ytemp=ytemp_ram.s;             
realscalar ytempb_ram;unsigned int *ytempb=ytempb_ram.s;          
realscalar ytempc_ram;unsigned int *ytempc=ytempc_ram.s;          
realscalar yxsave_ram;unsigned int *yxsave=yxsave_ram.s;          
realscalar yfsave_ram;unsigned int *yfsave=yfsave_ram.s;          
realscalar yf1save_ram;unsigned int *yf1save=yf1save_ram.s;       
realscalar yxxx_ram;unsigned int * yxxx=yxxx_ram.s;               
realscalar ylam_ram;unsigned int *ylam=ylam_ram.s;                
realscalar ylamroot_ram;unsigned int *ylamroot=ylamroot_ram.s;    

realvector ya_ram;unsigned int * *ya=ya_ram.v;                     
realvector yb_ram;unsigned int * *yb=yb_ram.v;                     
realvector ypoly1in_ram;unsigned int * *ypoly1in=ypoly1in_ram.v;   
realvector ypoly2in_ram;unsigned int * *ypoly2in=ypoly2in_ram.v;   
realvector yc_ram;unsigned int * *yc=yc_ram.v;
realvector yxrot_ram;unsigned int * *yxrot=yxrot_ram.v;
realvector yyrot_ram;unsigned int * *yyrot=yyrot_ram.v;
realvector yq_ram;unsigned int * *yq=yq_ram.v;
realvector ydr_ram;unsigned int * *ydr=ydr_ram.v;
realvector ydq_ram;unsigned int * *ydq=ydq_ram.v;
realvector ydrpr_ram;unsigned int * *ydrpr=ydrpr_ram.v;
realvector ydqpr_ram;unsigned int * *ydqpr=ydqpr_ram.v;           
realvector yr_ram;unsigned int * *yr=yr_ram.v;
realvector yqpr_ram;unsigned int * *yqpr=yqpr_ram.v;
realvector yrpr_ram;unsigned int * *yrpr=yrpr_ram.v;
realvector yqorig_ram;unsigned int * *yqorig=yqorig_ram.v;
realvector yapoly_ram;unsigned int * *yapoly=yapoly_ram.v;        

int *ymess;               
int pideclarations=polydeclarations();
int polydeclarations()   
  {ymess = new int [zmaxsizepad];           
   return 0;
  }

int solvpoly(int ynpoly,unsigned int * *yapoly) 
  {for (yi=0;yi<prec+2;yi++)
    {y1D16[yi]=0;
     y1Dm5[yi]=0;}
   y1D16[prec+1]=2;     //set signs 
   y1Dm5[prec+1]=2;      
   y1D16[prec]=819200;   //8192 in class     
   y1D16[0]=2+0x40000000;    
   y1Dm5[prec]=524350000;  
   y1Dm5[0]=-1+0x40000000;
yhugeback:
   ynpasses=0;
   yn2=ynpoly;
   zconinttomp(1);
   zstore(ylamroot);
   for (yi=0;yi<yn2+1;yi++)
     {zrecall(yapoly[yi]);
      zstore(ya[yi]);}
ywayback: ynisnow=1;
 for (yi=0;yi<yn2;yi++)
  {zdiv(ya[yi],ya[yn2]);
   zstore(ya[yi]);}
   zconinttomp(1);
   zstore(ya[yn2]);       
   zabs(ya[0]);
   zlog(z);
   zdivint(z,yn2);   //aqui
   zexp(z);
   zstore(ylam);
   zmult(ylamroot,ylam);
   zstore(ylamroot);
   for (yi=1;yi<yn2+1;yi++)
     {zxtonth(ylam,yi);
      zmult(ya[yi],z);
      zdiv(z,ya[0]);
      zstore(ya[yi]);
     }
   zconinttomp(1);
   zstore(ya[0]);
   if (ya[yn2][prec+1]==0)
     {for (yi=0;yi<yn2+1;yi++)
        {ya[yi][prec+1]=2-ya[yi][prec+1];}
     }
   for (yi=0;yi<yn2+1;yi++)
     {zzero(yq[yi]);
      zzero(yr[yi]);
      zzero(yqpr[yi]);
      zzero(yrpr[yi]);
      zzero(ydq[yi]);
      zzero(ydr[yi]);
     }
   for (yi=0;yi<prec+1;yi++)
     {yxoldmax[yi]=0;}
   yxoldmax[prec]=1; 
   yxoldmax[prec+1]=2;
   yxoldmax[0]=9999+0x40000000;
   ynpassq=0;
   yerrorflag=0;
   yerrorflag=yerrorflag+1;
   yfindmax();
   zsub(yxmax,yxoldmax);
   if (z[prec+1]==2 && z[prec]>0)
     {zrecall(yxoldmax);
      zstore(yxmax);
      goto ybhyu;
     }
   zrecall(yxmax);
   zstore(yxoldmax);
ybhyu:
     if (ynpassq==0)
      {zrecall(yxmax);
       zchs(z);
       zstore(yxleft);
       ynpassq=1;
      }
   zrecall(ya[yn2]);
   zabs(z);
   zstore(yfmax);
   for (yj=yn2-1;yj>=0;yj--)
     {zrecall(yfmax);
      zmult(yxmax,z);
      zstore(yfmax);
      zrecall(ya[yj]);
      zabs(z);
      zadd(z,yfmax);
      zstore(yfmax);
     }
    ymessage2=1;
    yrealroot();
    if (ymessage==1)
      {ynisnow=3;
       zrecall(yxmax); 
       zchs(z);
       zstore(yxleft);
       goto yahead3;
      }
    if (ymessage==2)
      {ynpasses=ynpasses+1;
       ymess[ynpasses]=2;
       zmult(yx,ylamroot);
       zstore(yxrot[ynpasses]);
       cerr<<"r";
       if (yn2==ynpoly)
         {zdiv(z,ylam);
          zstore(yx);
         }
       ydivideout1();
       if (yn2==0)             
         {goto yahead12;}
       goto ywayback;
      }
yahead2: ynisnow=2;
    ymessage2=2;
    yrealroot();
    if (ymessage==1) goto yendbit; 
    if (ymessage==2) 
      {ynpasses=ynpasses+1;
       ymess[ynpasses]=2;
       zmult(yx,ylamroot); 
       zstore(yxrot[ynpasses]);
       cerr<<"r";
       ydivideout1();
       if (yn2==0)
         {goto yahead12;}
       goto ywayback;
      }
yahead3: 
    yk=yn2/2;
    yk=2*yk;
    if (yk==yn2)
      {ynisnow=3; 
       goto yahead11;
      }
    ymeshpatch();
    goto yhugeback;
yahead11:
    ymessage2=3;
    yrealroot();
    if (ymessage==1)
      {zrecall(yxmax);
       zchs(z);
       zstore(yxleft);
       goto yahead33;}
    if (ymessage==3)
      {zrecall(yw);
       zchs(z);
       zsqrt(z);             
       zstore(yu2);
       ynpasses=ynpasses+1;
       ymess[ynpasses]=3;
       zmult(yx,ylamroot);
       zstore(yxrot[ynpasses]);
       zmult(yu2,ylamroot); 
       zstore(yyrot[ynpasses]);
       cerr<<"cr";
       ydivideoutcomplex();
       if (yn2==0)
         {goto yahead12;}
       goto ywayback;
      }
yahead33: ynisnow=4;
    ymessage2=4;                    
    yrealroot(); 
    if (ymessage==3)
      {if (yw[prec+1]==2 && yw[prec]>0)
         {zzero(yu2);
          goto yblaha;
         }
       zrecall(yw);
       zchs(z);
       zsqrt(z);                 
       zstore(yu2);
yblaha: ynpasses=ynpasses+1;
       ymess[ynpasses]=ymessage;
       zmult(yx,ylamroot);
       zstore(yxrot[ynpasses]);
       zmult(yu2,ylamroot);
       zstore(yyrot[ynpasses]);
       cerr<<"cr";
       ydivideoutcomplex();
       if (yn2==0)
         {goto yahead12;}
       goto ywayback;
      }
    zrecall(yfmax);
    zchs(z);
    zstore(yxleft);
    goto yahead2;

yendbit:
      cerr<<yn2<<" roots remain to be found."<<'\n';   
      cerr<<"If the following answer is n (no) the"<<'\n';
      cerr<<"roots found will be reported."<<'\n';
      cerr<<"Shall another try be made with finer meshes? (y/n,default n)";
      cerr<<"The roots already found will be discarded and the search"<<'\n';
      cerr<<"begun anew with the original polynomial"<<'\n';
      cin>>zmessage;
      if (zmessage=="y") 
         {ymeshpatch();
          goto yhugeback;}

yahead12: cerr<<'\n';
          return 0;
  }

int ymeshpatch() 
  {ynten1=2*ynten1;
   cerr<<"going to yhugeback"<<'\n';
   if (ynten1>=10000)
     {cerr<<"ynten1>=10000"<<'\n';
      cerr<<"input any character to continue";
      cin>>zqqq;}
   return 0;
  }

int yfindmax()                  
  {int yfindflag;
   zconinttomp(1);
   zdivint(z,10);                         
   zstore(ydel);
   zconinttomp(1);
   zstore(yxxx);
   yfindflag=0;
yback:
   if (yfindflag==0)
     {zconinttomp(1);
      zstore(yx);
     }
   if (yfindflag==1)
     {zdivint(yx,2);
      zstore(yx);
     }
   if (yfindflag==2)
     {zmultint(yx,2);
      zstore(yx);
     }
   zabs(ya[yn2]);          
   zstore(yf);
   for (yi=yn2-1;yi>=0;yi--)
     {zmult(yf,yx);
      zstore(yf);
      zabs(ya[yi]);
      zsub(yf,z);
      zstore(yf);
     }
   if (yf[prec+1]==0) 
     {if (yfindflag==0)
        {yfindflag=2;             
         goto yback;
        }
      if (yfindflag==1)           
        {zmultint(yx,2);              
         zstore(yx);
         goto yfinishit;}
      if (yfindflag==2)          
        {goto yback;}
      }
   if (yf[prec]==0)
      {goto yfinishit;}
   if (yf[prec+1]==2 && yf[prec]>0)
     {if (yfindflag==2)           
        {goto yfinishit;}
      if (yfindflag==0)
        {yfindflag=1;             
         goto yback;
        }
      if (yfindflag==1)          
        {goto yback;}            
     }
yfinishit: zrecall(yx);
   zstore(yxmax);
   return 0;
  }

int ydivideout1()
  {int ykk;
   for (yj=0;yj<yn2+1;yj++)
     {zzero(yc[yj]);}
   zrecall(ya[yn2]);
   zstore(yc[yn2-1]);
   for (ykk=yn2-2;ykk>=0;ykk--)
     {zmult(yx,yc[ykk+1]);
      zadd(z,ya[ykk+1]);
      zstore(yc[ykk]);
     }
   for (ykk=0;ykk<yn2;ykk++)
     {zrecall(yc[ykk]);
      zstore(ya[ykk]);
     }
   yn2=yn2-1;
   return 0;
  }

int ydivideoutcomplex()
  {int ykk;
   for (yj=0;yj<yn2+1;yj++)
     {zzero(yc[yj]);}
   zrecall(ya[yn2]);
   zstore(yc[yn2-2]);
   if (yn2>2)
     {zmult(yx,ya[yn2]);
      zmultint(z,2);
      zadd(z,ya[yn2-1]);
      zstore(yc[yn2-3]);
      for (ykk=yn2-4;ykk>=0;ykk--)
        {zmult(yx,yx);
         zstore(ytemp);
         zmult(yu2,yu2);
         zadd(z,ytemp);
         zmult(z,yc[ykk+2]);
         zstore(ytemp);
         zmult(yx,yc[ykk+1]);
         zmultint(z,2);
         zsub(z,ytemp);
         zadd(z,ya[ykk+2]);
         zstore(yc[ykk]);
        }
     }
   for (ykk=0;ykk<yn2-1;ykk++)
     {zrecall(yc[ykk]);
      zstore(ya[ykk]);
     }
   yn2=yn2-2;
   return 0;
  }

int yrealroot()
  {
   yimax=ynten1;
   zconinttomp(yimax);
   zdiv(yxmax,z);
   zmultint(z,100);
   zdivint(z,99);
   zstore(ydel);
   ynpassq2=0;
   for (yi=-yimax;yi<yimax+1;yi++)
     {
      yiabs=abs(yi);
      zmultint(ydel,yiabs);
      if (yi<0) zchs(z);
      zstore(yx);
      zconinttomp(1);
      zdivint(z,10);
      zadd(z,yx);
      zsub(z,yxleft);
      if (z[prec+1]==0)
        {goto yni5;}
      ywhateverf();
      if (ynpassq2==0)
        {ynpassq2=1;
         goto yni5;
        }
      if (yi==-yimax)
        {goto yni5;}
      if (ynisnow==1 || ynisnow==3)
        {goto yaroundf1;}
      if (yf1[prec]==0)                                        
        {ysaveistep2();
         goto yahead500;
        }
      zmult(yf1,yf1prev);                                     
      if (z[prec+1]==0)
        {ysaveistep2();
         zrecall(yf1); 
         zstore(yf);
         zrecall(yf1prev);
         zstore(yfprev);
         ymessage2=3;
         yiterate(); 
         goto yahead500;   
        }
yaroundf1: zchs(z);
      if (yf[prec]==0)                                                 
        {ysaveistep2();
         goto yahead500;          
        }                                                          
      zmult(yfprev,yf);

if (zpqr==7070)
  {zprnt(yfprev);
   zprnt(yf);
   zprnt(z);
   zmessage="look at sign of last";
   zbreak();
  }

      if (z[prec+1]==0 && z[prec]!=0)  //this means negative, but -0 
        {                              //goes as well
         ysaveistep2();               //the other way: it won't go here
         if (ynisnow==4) ymessage2=4;
         if (ynisnow==2) ymessage2=2;
         yiterate();
         goto yahead500;       
        }
      goto yni5;
yahead500: zchs(z);                     
      if (ynisnow==1)
        {ymessage=2;
         goto yahead200;} 
      yimportant=yi;
      yimaximportant=yimax;
      ytestroot();                   //aqui --hmm
      if (ynisnow==2)
        {if (ymessage==5)
           {ymessage=2;
            goto yahead200;
           }
        }
      if (ynisnow>2)
        {if (ymessage==5)
           {ymessage=3;
            goto yahead200;}
        }
      yrecoveristep2();
yni5: zrecall(yf1);
      zstore(yf1prev);
      zrecall(yf);
      zstore(yfprev);
      zrecall(yx);
      zstore(yxprev);
     }
   ymessage=1;     
yahead200:
   return 0;
  }

int ywhateverf()
  {if (ymessage2==1) 
      {yfunc();}
   if (ymessage2==2)
      {ydfdx();}
   if (ymessage2==3)  
      {yr0();}
   if (ymessage2==4)
      {yr0dr0();}
   if (ymessage2==5) 
      {yqw();}
   if (ymessage2==6)
      {yqwdqw();}
   return 0;                 
  }

int ysaveistep()
  {zrecall(yf);
   zstore(yfsave5);
   zrecall(yf1);
   zstore(yf1save5);
   zrecall(yfprev);
   zstore(yfprevsave5);
   zrecall(yf1prev);
   zstore(yf1prevsave5);
   ymessagesave5=ymessage;
   return 0;
  }

int ysaveistep2()
  {zrecall(yf);
   zstore(yfsave55);
   zrecall(yf1);
   zstore(yf1save55);
   zrecall(yfprev);
   zstore(yfprevsave55);
   zrecall(yf1prev);
   zstore(yf1prevsave55);
   ymessagesave55=ymessage;
   return 0;
  }

int yiterate()
  {int yniter;
   ynitermax=24*prec;
   yniter=0;
yback1:
   zrecall(yx);
   zstore(yxsave);
   zrecall(yf);
   zstore(yfsave);
   if (ymessage2==6 || ymessage2==4 || ymessage2==2) 
     {zrecall(yf1);
      zstore(yf1save);}
   yniter=yniter+1;
   zadd(yx,yxprev);
   zdivint(z,2);
   zstore(yx); 
   ywhateverf();        

if (ymessage2==6 || ymessage2==4 || ymessage2==2)
  {if (yf1[prec]==0) goto yxit;
   zmult(yf1prev,yf1);
   if (z[prec+1]==0)
     {if (yniter>ynitermax) goto yxit;
      zrecall(yf1);
      zstore(yf);
      zrecall(yf1prev);
      zstore(yfprev);
      yiterate2(yniter);
      goto yxit;
     }
  }

   if (yf[prec]==0)
     {goto yxit;}
   zmult(yfprev,yf);
   if (z[prec+1]==0)
     {if (yniter>ynitermax) goto yxit;
      goto yback1; 
     }
   if (yniter>ynitermax)
     {zrecall(yxprev);
      zstore(yx);
      goto yxit;
     }
   zrecall(yf);
   zstore(yfprev);
   if (ymessage2==6 || ymessage2==4 || ymessage2==2)
      {zrecall(yf1);
       zstore(yf1prev);
      }
   zrecall(yx);
   zstore(yxprev);
   zrecall(yfsave);
   zstore(yf);
   if (ymessage2==6 || ymessage2==4 || ymessage2==2)
     {zrecall(yf1save); 
      zstore(yf1);}
   zrecall(yxsave);     
   zstore(yx);          
   goto yback1;
   zmessage="error in yiterate";
   zbreak();
yxit: 
   return 0;
  }

int yiterate2(int yniter2)
  {int ynitermax2;
   ynitermax2=24*prec;
yback2:
   zrecall(yx);
   zstore(yxsave);
   zrecall(yf);
   zstore(yfsave);
   yniter2=yniter2+1;
   zadd(yx,yxprev);
   zdivint(z,2);
   zstore(yx); 
   if (ymessage2==6) yqw();        
   if (ymessage2==4) yr0();
   if (ymessage2==2) yfunc();
   if (yf[prec]==0)
     {goto yxit2;}
   zmult(yfprev,yf);
   if (z[prec+1]==0)
     {if (yniter2>ynitermax2)
       {goto yxit2;}
      goto yback2; 
     }
   if (yniter2>ynitermax2)
     {zrecall(yxprev);
      zstore(yx);
      goto yxit2;
     }
   zrecall(yf);
   zstore(yfprev);
   zrecall(yx);
   zstore(yxprev);      
   zrecall(yfsave);
   zstore(yf);
   zrecall(yxsave);     
   zstore(yx);          
   goto yback2;
   zmessage="error in yiterate2";
   zbreak();
yxit2: return 0;
   }

int ytestroot()
  {
   if (ynisnow==4)
     {goto ybypasspass;}
   if (ymessage2==2)
     {yfunc();
      zabs(yf);
      zstore(ytemp); 
      zdiv(yfmax,y1D16);
      zsub(ytemp,z);
      if (z[prec+1]==0)
        {ymessage=5;
         goto yahead21;             //exit
        }
      ymessage=6;
      goto yahead21;                //exit
     }
ybypass:
   if (ymessage2==3) 
     {zabs(yq[1]);                          
      zsub(z,y1Dm5);
      if (z[prec+1]==2 && z[prec]>0)
        {zdiv(yq[0],yq[1]);
         if (z[prec+1]==2 && z[prec]>0)
           {ymessage=5;
            zchs(z);
            zstore(yw);
            goto yahead21;          //exit
           }
        }
     }
   if (ynisnow<4)
     {ymessage=6;
      goto yahead21;
     }
ybypasspass:
   ymessage=5;
   yrealroot2();      
yahead21:
   return 0;          
  }                   

int yrealroot2()          
  {int yimaxyip;
   zrecall(yx);
   zstore(yx2save);
   zmult(yxmax,yxmax);
   zstore(yxmaxmax);
   zchs(z);
   zstore(yxlower);
   yimaxyip=ynten1; 
   zdivint(yxmaxmax,yimaxyip);
   zmultint(z,100);
   zdivint(z,99);
   zstore(ydel);
   ynpassq2=0;
   for (yi=yimaxyip;yi>=0;yi--)
     {zmultint(ydel,yi);
      zchs(z);
      zstore(yx);
      zconinttomp(1);
      zdivint(z,10);
      zadd(z,yx);
      zsub(z,yxlower);
      if (z[prec+1]==0)
        {goto yni55;}
      if (ynpassq2==0)
        {yqwdqw();
         ynpassq2=1;
         goto yni55;
        }
      yqwdqw();
      if (yi==yimaxyip)        
        {goto yni55;}
      if (yf1[prec]==0)
        {goto yahead500pr;}
      zmult(yf1prev,yf1);
      if (z[prec+1]==0)
        {ysaveistep();
         zrecall(yf1);
         zstore(yf);
         zrecall(yf1prev);
         zstore(yfprev);
         ymessage2=5;
         yiterate();
         goto yahead500pr; 
        }
      if (yf[prec]==0)
        {ysaveistep();
         goto yahead500pr;
        }
      zmult(yfprev,yf);
      if (z[prec+1]==0)
        {ysaveistep();
         ymessage2=6;
         yiterate();                                  
         goto yahead500pr;
        }
      goto yni55;
yahead500pr:  zconinttomp(1);
      z[0]=0x40000000;
      zdivint(z,8192);
      zstore(ytemp);
      yqw();              
      zabs(yf);
      zsub(z,ytemp); 
      if (z[prec+1]==0) goto yahead200pr;
      yrecoveristep();                    
yni55: zrecall(yf1);
      zstore(yf1prev);
      zrecall(yf);
      zstore(yfprev);
      zrecall(yx);
      zstore(yxprev);
     } 
     if (yimportant==yimaximportant)
       {cerr<<'\n';
        zmessage="error in yrealroot2";
        zbreak();
       }
yahead200pr: zrecall(yx);
             zstore(yw); 
             zrecall(yx2save);
             zstore(yx);
   return 0;
  }
   
int yqw()                                
  {int yjp;
   zrecall(yqorig[yn2/2]); 
   zstore(yf);
   for (yjp=(yn2/2)-1;yjp>=0;yjp--)
     {zmult(yx,yf);
      zadd(z,yqorig[yjp]);
      zstore(yf);
     }
    return 0;
   }

int ydqw()
  {int yip,yjp; 
   yip=yn2/2;
   zrecall(yqorig[yn2/2]);
   zmultint(z,yip);
   zstore(yf);
   for (yjp=(yn2/2)-2;yjp>=0;yjp--)
     {zmult(yx,yf);  
      zstore(ytemp);          
      yip=yjp+1;
      zmultint(yqorig[yjp+1],yip);
      zadd(z,ytemp);          
      zstore(yf);
     }
   return 0;
  }

int yqwdqw()
  {yqw();
   zrecall(yf);
   zstore(yf1);
   ydqw();
   return 0;
  }


int yrecoveristep()
  {zrecall(yfsave5);
   zstore(yf);
   zrecall(yf1save5);
   zstore(yf1);
   zrecall(yfprevsave5);
   zstore(yfprev);
   zrecall(yf1prevsave5);
   zstore(yf1prev);
   ymessage=ymessagesave5;
   return 0;
  }

int yrecoveristep2()
  {zrecall(yfsave55);
   zstore(yf);
   zrecall(yf1save55);
   zstore(yf1);
   zrecall(yfprevsave55);
   zstore(yfprev);
   zrecall(yf1prevsave55);
   zstore(yf1prev);
   ymessage=ymessagesave55;
   return 0;
  }

int yfunc()
   {int yj2;
    zrecall(ya[yn2]);
    zstore(yf);
    for (yj2=yn2-1;yj2>=0;yj2--)
      {zmult(yx,yf);
       zadd(z,ya[yj2]);
       zstore(yf);
      }
    return 0;
   }

int ydfdx()
   {int yj3;
    yfunc();
    zstore(yf1);
    zmultint(ya[yn2],yn2);
    zstore(yf);
    for (yj3=yn2-2;yj3>=0;yj3--)
      {zmult(yx,yf);
       zstore(ytemp);
       zmultint(ya[yj3+1],yj3+1);
       zadd(z,ytemp);
       zstore(yf);
      }
    return 0;
   }

int yr0()
   {int yisavezit;
    yisavezit=yi; 
    yp=yn2/2;
    yoriglq();         
    yiterq();
    zrecall(yr[0]);
    zstore(yf); 
    yi=yisavezit;
    return 0;
   }

int yr0dr0()            
   {int yisaveugh;
    yp=yn2/2;
    yisaveugh=yi;
    yoriglq();
    yorigldq();          
    yiterdq();           
    zrecall(yr[0]);
    zstore(yf1);
    zrecall(ydr[0]);
    zstore(yf);
    yi=yisaveugh;
    return 0;
   }

int yorigldq()
  {int ykk;
   for (ykk=0;ykk<yp;ykk++)
     {zmultint(yr[ykk],2);
      zmultint(z,ykk);
      zadd(z,yr[ykk]);               
      zstore(ydq[ykk]);
      zmultint(yq[ykk+1],ykk);
      zadd(z,yq[ykk+1]);            
      zmultint(z,2);
      zstore(ydr[ykk]);
     }
   return 0;
  }

int yiterdq()
  {int ypp;
   for (ypp=yp;ypp>=2;ypp--)
     {for (yk=0;yk<ypp;yk++)
       {if (yk==0)
         {zmult(yq[yk],yr[ypp-1]);
          zstore(yqpr[yk]);
          zmult(ydq[yk],yr[ypp-1]);
          zstore(ytemp);                    
          zmult(yq[yk],ydr[ypp-1]);
          zadd(z,ytemp);                    
          zstore(ydqpr[yk]);
          goto yapr;
         }
        zmult(yq[ypp],yr[yk-1]);
        zstore(ytemp);                       
        zmult(yq[yk],yr[ypp-1]);
        zsub(z,ytemp);                        
        zstore(yqpr[yk]);
        zmult(yq[ypp],ydr[yk-1]);
        zstore(ytemp);                       
        zmult(ydq[ypp], yr[yk-1]);
        zadd(z,ytemp);                       
        zstore(ytemp);                       
        zmult(yq[yk],ydr[ypp-1]);
        zsub(z,ytemp);                        
        zstore(ytemp);                        
        zmult(ydq[yk],yr[ypp-1]);
        zadd(z,ytemp);                         
        zstore(ydqpr[yk]);
yapr:   zrecall(yr[yk]);
        zstore(yrpr[yk]);
        zrecall(ydr[yk]);
        zstore(ydrpr[yk]);
       }
      for (yk=0;yk<ypp;yk++)
       {zrecall(yrpr[yk]);
        zstore(yq[yk]);
        zrecall(ydrpr[yk]);
        zstore(ydq[yk]);
       }
      for (yk=0;yk<ypp-1;yk++)
       {zmult(yqpr[ypp-1],yrpr[yk]);
        zstore(ytemp);                     
        zmult(yqpr[yk],yrpr[ypp-1]);
        zsub(z,ytemp);                     
        zstore(yr[yk]);
        zmult(yqpr[ypp-1],ydrpr[yk]);
        zstore(ytemp);                     
        zmult(ydqpr[ypp-1], yrpr[yk]);
        zadd(z,ytemp);                     
        zstore(ytemp);                     
        zmult(yqpr[yk],ydrpr[ypp-1]);
        zsub(z,ytemp);                     
        zstore(ytemp);                     
        zmult(ydqpr[yk], yrpr[ypp-1]);
        zadd(z,ytemp);                     
        zstore(ydr[yk]);
       }
     }
   return 0;
  }
      
int yoriglq()                                 
   {int yi7,yj7,yk7,ym7,ykk;
    yfunc();                      
    zrecall(yf);
    zstore(yq[yp]);               
    for (yi7=1;yi7<yn2+1;yi7++)
      {zrecall(ya[yi7]);
       zstore(yb[yi7]);
      }
    for (yk7=1;yk7<yn2+1;yk7++)               
      {for (yj7=1;yj7<yn2-yk7+2;yj7++)        
        {zmultint(yb[yj7],yj7);               
         zdivint(z,yk7);
         zstore(yb[yj7-1]);                   
        }                                     
       ym7=yk7/2;
       ym7=2*ym7;
       if (yk7==ym7)              
         {ym7=yk7/2;              
          zzero(yq[yp-ym7]);
          for (yi7=0;yi7<yn2-yk7+1;yi7++)     
            {zxtonth(yx,yi7);                 
             zmult(z,yb[yi7]);                
             zadd(z,yq[yp-ym7]);
             zstore(yq[yp-ym7]);         
            }
            goto ynk7;
         }
       ym7=(yk7+1)/2;
       zzero(yr[yp-ym7]);
       for (yi7=0;yi7<yn2-yk7+1;yi7++)
         {zxtonth(yx,yi7);
          zmult(z,yb[yi7]);
          zadd(z,yr[yp-ym7]);
          zstore(yr[yp-ym7]);
         }
ynk7: continue;
      }                                    
    for (ykk=0;ykk<yp+1;ykk++)             
      {zrecall(yq[yp-ykk]);               
       zstore(yqpr[ykk]);                 
      }
    for (ykk=0;ykk<yp;ykk++)
      {zrecall(yr[yp-1-ykk]);
       zstore(yrpr[ykk]);
      }
    for (ykk=0;ykk<yp+1;ykk++)           
      {zrecall(yqpr[ykk]);
       zstore(yq[ykk]);
       zrecall(yrpr[ykk]);
       zstore(yr[ykk]);
      }
    for (yj7=0;yj7<yp+1;yj7++)
      {zrecall(yq[yj7]);
       zstore(yqorig[yj7]);
      }
    return 0;
   }

int yiterq()
   {int ypp,yk8;
    for (ypp=yp;ypp>=2;ypp--)           
      {for (yk8=0;yk8<ypp;yk8++)
        {if (yk8==0)
           {zmult(yq[yk8],yr[ypp-1]);
            zstore(yqpr[yk8]);
            goto yapril;
           }
         zmult(yq[yk8],yr[ypp-1]);
         zstore(ytemp);                   
         zmult(yq[ypp],yr[yk8-1]);
         zchs(z);
         zadd(z,ytemp);                   
         zstore(yqpr[yk8]);
yapril:  zrecall(yr[yk8]);
         zstore(yrpr[yk8]);
        }                          
       for (yk8=0;yk8<ypp;yk8++)
        {zrecall(yrpr[yk8]);  
         zstore(yq[yk8]);
        }
       for (yk8=0;yk8<ypp-1;yk8++)
        {zmult(yqpr[ypp-1],yrpr[yk8]); 
         zstore(ytemp);                      
         zmult(yqpr[yk8],yrpr[ypp-1]);
         zsub(z,ytemp);                      
         zstore(yr[yk8]);
        }
      }
    return 0;
   }

int multpolys(int yn1in,unsigned int * *ypoly1in,int yn2in,unsigned int * *ypoly2in)
   {int yj9,yj8;
   for (yj9=0;yj9<yn1in+yn2in+1;yj9++)
     {zzero(yb[yj9]);}
   for (yj8=0;yj8<yn1in+yn2in+1;yj8++) 
     {for (yj9=0;yj9<yn1in+1;yj9++)
        {if (yj8-yj9>yn2in) goto ybkyl; 
         if (yj8-yj9<0) goto ybkyl;
         zmult(ypoly1in[yj9],ypoly2in[yj8-yj9]);
         zadd(z,yb[yj8]);
         zstore(yb[yj8]);
ybkyl: continue;
        }
     }
   return 0;
  }


int multiplyout()
  {int yj9,ynnn; 
   for (yj9=0;yj9<ynpoly+1;yj9++)
     {zzero(yb[yj9]);}
   ynnn=0;   
   zconinttomp(1);
   zstore(yb[0]);
   for (yi=1;yi<ynpasses+1;yi++)
     {if (ymess[yi]==2)
        {ynnn=ynnn+1;
         zconinttomp(1);
         zstore(yb[ynnn]);
         for (yj=ynnn-1;yj>=1;yj--)
           {zmult(yxrot[yi],yb[yj]);
            zchs(z);
            zadd(z,yb[yj-1]);
            zstore(yb[yj]);
           }
         zmult(yxrot[yi],yb[0]);
         zchs(z);
         zstore(yb[0]);
         goto yfred;
        }
      zmultint(yxrot[yi],2);
      zstore(ytempb);
      zmult(yyrot[yi],yyrot[yi]);
      zstore(ytemp);                   
      zmult(yxrot[yi],yxrot[yi]);
      zadd(z,ytemp);                   
      zstore(ytempc);
      ynnn=ynnn+2;
      zconinttomp(1);
      zstore(yb[ynnn]);
      if (ynnn==2)
        {zmult(ytempb,yb[0]);
         zchs(z);
         zstore(yb[1]);
         zmult(ytempc,yb[0]);
         zstore(yb[0]);
         goto ypuwe;
        }
      zmult(ytempb,yb[ynnn-2]);
      zchs(z);
      zadd(z,yb[ynnn-3]);
      zstore(yb[ynnn-1]);
      for (yj=ynnn-2;yj>=2;yj--)
        {zmult(ytempc,yb[yj]);
         zstore(ytemp);                     
         zmult(ytempb,yb[yj-1]);
         zchs(z);
         zadd(z,ytemp);                      
         zadd(z,yb[yj-2]);
         zstore(yb[yj]);
        }
      zmult(ytempc,yb[1]);
      zstore(ytemp);                          
      zmult(ytempb,yb[0]);
      zchs(z);
      zadd(z,ytemp);                          
      zstore(yb[1]);
      zmult(ytempc,yb[0]);
      zstore(yb[0]);
ypuwe: 
yfred: zchs(z);         
     }
   return 0;
  }