#######################################################
## make-win-package ramarobinsids
## Wed, Aug 10, 2016  1:19:14 PM
#######################################################
#######################################################

printf("BEGIN ramarobinsids package\n");
printf("THIS VERSION DATED Wed, Aug 10, 2016  1:19:14 PM \n");
ramarobinsids:=table();
ramarobinsids[CHECKRAMIDF]:=proc(SYMF,ACC,T)
 local T1,T2,T3,X2,C2,SC2,P2,PL2,PLX,SP,GHbool; 
   global S,S2,_JFUNC,LDQ,RID,SYMID:
   global qthreshold,proveit,ebasethreshold,ebtprob:
   global EBL,PL,CHECKSYMF,xprint:
        if not(type(qthreshold,integer)) then
          qthreshold:=1000: 
        fi:
        if not(type(ebasethreshold,integer)) then
          ebasethreshold:=1000: 
        fi:
        if not(type(proveit,boolean)) then
          proveit:=false:
        fi:
        if not(type(ebtprob,boolean)) then
          ebtprob:=false:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   GHbool:=map( x-> type(x,procedure),{G,H,HM,GM})[1];
   if not GHbool then
     ERROR(`G,H,HM,GM are not defined`);
   fi:
   CHECKSYMF:=SYMF:
   PL:=[]:
   T1:=T:
   T2:=trunc(9*T/10):
   T3:=trunc(8*T/10):
   if xprint then
     print(SYMF);
   fi:
   _JFUNC:=eval(subs({_H=H,_G=G,_HM=HM,_GM=GM},SYMF)):
   _JFUNC:=radsimp(_JFUNC):
   S:=series(jac2series(_JFUNC,T1),q,T1):
   SP:=convert(S,polynom):
   ##print(series(S,q,10));
   LDQ:=lqdegree(S):
   ##print("LDQ=",LDQ);
   S2:=series(S/q^LDQ,q,T2):
   ##print(series(S2,q,10));
   ##print("S2=",series(S2,q,10));
   X2:=convert(S2,polynom):
   if X2=FAIL then
     RETURN():
   fi:
   if xprint then
      print("TYPE INT LDQ=",type(LDQ,integer), "XC3=",XC3);
   fi:
   C2:=coeff(S2,q,0):
   if xprint then
     print("C2=",C2):
   fi:
   if C2=0 then
     RETURN():
   fi:
   SC2:=series(S2/C2,q,T2):
   P2:=convert(SC2,polynom):
   if P2<>FAIL then
     ##print(prodmake(S2/C2,q,10,list));
     PL:=prodmake(S2/C2,q,T3,list):
     PL2:=map(abs,PL):
     PLX:=max(PL2):
     if PLX < ACC then
       RID:=etamake(series(jac2series(_JFUNC,T2)/q^LDQ,q,T2),q,T3)*q^LDQ;
       if ebase>ebasethreshold then
         if xprint then
           printf("WARNING: ebase=%a\n",ebase);
         fi:
         ebtprob:=true:
         ##add EBL:
         EBL:=[op(EBL),SYMF]:
         RETURN():
       fi:
       SYMID:=SYMF=RID:
       ##RETURN([a,b,c2],PL);
       RETURN(PL);
     else
       RETURN():
     fi:
   fi:
end:
 ramarobinsids[Eeta]:=n->q^(n/24)*JAC(0,n,infinity):
ramarobinsids[findtype1]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,EB,SYMF,nm,pmf;
 global xprint,NEWJACID,RJID,SYMJID:
 global TT1,TT2,PROVEDFL1,EBL:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
   EBL:=[]:
    IDLIST:=[]:
    PROVEDFL1:=[]:
    CS:={-1,1}:
    for n from 2 to T do
       nm:=modp(n,10):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       for p in numtheory[divisors](n) do
          for c1 in CS do
             a:=n/p:
             if a<>p and a<=p and igcd(a,p)=1 then
                SYMF:=_G(p)*_H(a) + c1*_G(a)*_H(p):
                ABCOND:=GE(p)+HE(a)-(GE(a)+HE(p));
                if type(ABCOND,integer) then
                   FF:=CHECKRAMIDF(SYMF,10,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,10,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
                    PROVEDFL1:=[op(PROVEDFL1),[p,a,c1,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([p,a,c1]);
                        print(SYMID);
##                        latexetaquot(_etalisttop,_etalistbot);
                        IDLIST:=[op(IDLIST),[p,a,c1]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
       od:
    od:
    RETURN(IDLIST):
end:
ramarobinsids[findtype2]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,EB,SYMF,nm,pmf;
 global xprint,NEWJACID,RJID,SYMJID:
 global TT1,TT2,PROVEDFL2,EBL:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
   EBL:=[]:
    IDLIST:=[]:
    PROVEDFL2:=[]:
    CS:={-1,1}:
    for n from 1 to T do
       nm:=modp(n,10):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       for p in numtheory[divisors](n) do
          for c1 in CS do
             a:=n/p:
             if  a<=p and igcd(a,p)=1 then
                SYMF:=_G(a)*_G(p) + c1*_H(a)*_H(p):
                ABCOND:=GE(a)+GE(p)-(HE(a)+HE(p));
                if type(ABCOND,integer) then
                   FF:=CHECKRAMIDF(SYMF,10,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,10,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
                    PROVEDFL2:=[op(PROVEDFL2),[a,p,c1,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([a,p,c1]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[a,p,c1]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
       od:
    od:
    RETURN(IDLIST):
end:
ramarobinsids[findtype3]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,EB,SYMF,nm,a1,a2,c2,p1,p2,
       COND1, COND2, dd2, pmf;
 global xprint,NEWJACID,RJID,SYMJID,EBL:
 global TT1,TT2,PROVEDFL3:
 global myramconsttype3:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   myramconsttype3:=[]:
   EBL:=[]:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
    IDLIST:=[]:
    PROVEDFL3:=[]:
    CS:={-1,1}:
    for n from 2 to T do
       nm:=modp(n,10):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       for p1 in numtheory[divisors](n) do
       for p2 in numtheory[divisors](n) do
          for c1 in CS do
          for c2 in CS do
             a1:=n/p1:
             a2:=n/p2:
             dd2:=igcd(a2,p2):
             ##HERE
             if a1<=p1  and  a2>p2 and igcd(a1,a2,p1,p2)=1
             and not(member([a2/dd2,p2/dd2,c2],convert(myramtype1,set))) then
                SYMF:=(_G(a1)*_G(p1) + c1 *_H(a1)*_H(p1))
                      /(_G(a2)*_H(p2)+c2*_H(a2)*_G(p2)):
                COND1:=GE(a1)+GE(p1)-HE(a1)-HE(p1):
                COND2:=GE(a2)+HE(p2)-HE(a2)-GE(p2):
                if type(COND1,integer) and type(COND2,integer) then
                   FF:=CHECKRAMIDF(SYMF,10,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,10,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if type(RJID,integer) then
                           myramconsttype3:=[op(myramconsttype3),
                           [a1,p1,c1,a2,p2,c2]];
                        fi:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
PROVEDFL3:=[op(PROVEDFL3),[a1,p1,c1,a2,p2,c2,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([a1,p1,c1,a2,p2,c2]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[a1,p1,c1,a2,p2,c2]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
          od:
       od:
       od:
    od:
    RETURN(IDLIST):
end:
ramarobinsids[findtype4]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,EB,nm,p2,a2,pmf;
 global xprint,NEWJACID,RJID,SYMJID,SYMF:
 global TT1,TT2,PROVEDFL4,EBL:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
   EBL:=[]:
    IDLIST:=[]:
    PROVEDFL4:=[]:
    CS:={-1,1}:
    for n from 2 to T do
       nm:=modp(n,5):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       for p in numtheory[divisors](n) do
          for c1 in CS do
             a:=n/p:
             a2:=modp(a,2): p2:=modp(p,2):
             if a<>p and a<=p and igcd(a,p)=1 and (a2=0 or p2=0) then
                SYMF:=_GM(p)*_HM(a) + c1*_GM(a)*_HM(p):
                ABCOND:=GE(p)+HE(a)-(GE(a)+HE(p));
                if type(ABCOND,integer) then
                ##print(SYMF);
                   FF:=CHECKRAMIDF(SYMF,10,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,10,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
PROVEDFL4:=[op(PROVEDFL4),[p,a,c1,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([p,a,c1]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[p,a,c1]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
       od:
    od:
    RETURN(IDLIST):
end:
ramarobinsids[findtype5]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,EB,SYMF,nm,a2,p2,pmf; 
 global xprint,NEWJACID,RJID,SYMJID:
 global TT1,TT2,PROVEDFL5,EBL:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
   EBL:=[]:
    IDLIST:=[]:
    PROVEDFL5:=[]:
    CS:={-1,1}:
    for n from 2 to T do
       nm:=modp(n,10):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       for p in numtheory[divisors](n) do
          for c1 in CS do
             a:=n/p:
             a2:=modp(a,2): p2:=modp(p,2):
             if a<=p and igcd(a,p)=1 and (a2=0 or p2=0) then
                SYMF:=_GM(a)*_GM(p) + c1*_HM(a)*_HM(p):
                ABCOND:=GE(p)+GE(a)-(HE(a)+HE(p));
                if type(ABCOND,integer) then
                ##print(SYMF);
                   FF:=CHECKRAMIDF(SYMF,10,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,10,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
PROVEDFL5:=[op(PROVEDFL5),[a,p,c1,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([a,p,c1]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[a,p,c1]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
       od:
    od:
    RETURN(IDLIST):
end:
ramarobinsids[findtype6]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,SYMF,nm,a2,p2,pmf;
 global xprint,NEWJACID,RJID,SYMJID,EB:
 global TT1,TT2,ebtprob,PROVEDFL6,EBL:
        if not(type(ebtprob,boolean)) then
          ebtprob:=false:
        fi:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   ebtprob:=false:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
   EBL:=[]:
    IDLIST:=[]:
    PROVEDFL6:=[]:
    CS:={-1,1}:
    for n from 1 to T do
       nm:=modp(n,10):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       for p in numtheory[divisors](n) do
          for c1 in CS do
             a:=n/p:
             a2:=modp(a,2): p2:=modp(p,2):
             if a>=p and igcd(a,p)=1  then
                SYMF:=_G(a)*_HM(p) + c1*_GM(a)*_H(p):
                ABCOND:=GE(a)+HE(p)-(GE(a)+HE(p));
                if type(ABCOND,integer) then
                ##print(SYMF);
                   if xprint then
                     printf("CHECKRAMIDF part 1, TT1=%a\n",TT1);
                   fi:
                   FF:=CHECKRAMIDF(SYMF,24,TT1):
                   if FF<>NULL then
                   if xprint then
                     printf("CHECKRAMIDF part 2, TT2=%a\n",TT2);
                   fi:
                      FF2:=CHECKRAMIDF(SYMF,24,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
PROVEDFL6:=[op(PROVEDFL6),[a,p,c1,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([a,p,c1]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[a,p,c1]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
       od:
    od:
    if ebtprob then
       printf("WARNING: There were %a ebasethreshold problems.\n",nops(EBL));
       printf("         See the global array EBL.\n");                         
    fi:
    RETURN(IDLIST):
end:
ramarobinsids[findtype7]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,EB,SYMF,nm,a2,p2,pmf;
 global xprint,NEWJACID,RJID,SYMJID:
 global TT1,TT2,PROVEDFL7,EBL:
 global ebtprob:
        if not(type(ebtprob,boolean)) then
          ebtprob:=false:
        fi:
        ebtprob:=false:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
   EBL:=[]:
    IDLIST:=[]:
    PROVEDFL7:=[]:
    CS:={-1,1}:
    for n from 1 to T do
       nm:=modp(n,10):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       for p in numtheory[divisors](n) do
          for c1 in CS do
             a:=n/p:
             a2:=modp(a,2): p2:=modp(p,2):
             if a<=p and igcd(a,p)=1  and (a2=1 and p2=1) then
                SYMF:=_GM(a)*_G(p) + c1*_HM(a)*_H(p):
                ABCOND:=GE(p)+GE(a)-(HE(a)+HE(p));
                if type(ABCOND,integer) then
                ##print(SYMF);
                   FF:=CHECKRAMIDF(SYMF,10,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,10,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
PROVEDFL7:=[op(PROVEDFL7),[a,p,c1,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([p,a,c1]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[a,p,c1]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
       od:
    od:
    if ebtprob then
       printf("WARNING: There were %a ebasethreshold problems.\n",nops(EBL));
       printf("         See the global array EBL.\n");                         
    fi:
    RETURN(IDLIST):
end:
ramarobinsids[findtype8]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,EB,SYMF,nm,a2,p2,pmf;
 global xprint,NEWJACID,RJID,SYMJID:
 global TT1,TT2,EBL,PROVEDFL8:
 global ebtprob:
        if not(type(ebtprob,boolean)) then
          ebtprob:=false:
        fi:
        ebtprob:=false:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   EBL:=[]:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
    IDLIST:=[]:
    PROVEDFL8:=[]:
    CS:={-1,1}:
    for n from 2 to T do
       nm:=modp(n,10):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       p:=n:                         
          for c1 in CS do
             a:=n/p:
             if p<>1 then
                SYMF:=_G(1)^p*_H(p)   + c1*_H(1)^p*_G(p):
                ##ABCOND:=GE(p)+GE(a)-(HE(a)+HE(p));
                ABCOND:=1:
                if type(ABCOND,integer) then
                ##print(SYMF);
                   FF:=CHECKRAMIDF(SYMF,10,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,10,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
PROVEDFL8:=[op(PROVEDFL8),[p,c1,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([p,c1]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[p,c1]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
    od:
    if ebtprob then
       printf("WARNING: There were %a ebasethreshold problems.\n",nops(EBL));
       printf("         See the global array EBL.\n");                         
    fi:
    RETURN(IDLIST):
end:
ramarobinsids[findtype9]:=proc()
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,b,FF,FF2,EB,SYMF,nm,a2,p2,pmf;
 local ISOL, SYMF1, SYMFS, ABL, x:
 global xprint,NEWJACID,RJID,SYMJID:
 global TT1,TT2,EBL,PROVEDFL9:
 global ebtprob:
        if not(type(ebtprob,boolean)) then
          ebtprob:=false:
        fi:
        ebtprob:=false:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   IDLIST:=[]:
   PROVEDFL9:=[]:
   EBL:=[]:
   ISOL:=isolve(GE(a)+HE(b)=0):       
   ISOL:=subs(_Z1=1,ISOL):
   SYMF1:=subs(ISOL,_G(1)^a*_H(1)^b - _H(1)^a*_G(1)^b):
   ABL:=subs(ISOL,[a,b]):   
   SYMFS:={SYMF1,SYMF1-1}:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
   for SYMF in SYMFS do
                if SYMF=SYMF1 then
                  x:=0:
                else
                  x:=1:
                fi:
                   FF:=CHECKRAMIDF(SYMF,20,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,20,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
PROVEDFL9:=[op(PROVEDFL9),[ABL[1],ABL[2],x,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([ABL[1],ABL[2],x]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[ABL[1],ABL[2],x]]:
                      fi:
                   fi:
    od:
    if ebtprob then
       printf("WARNING: There were %a ebasethreshold problems.\n",nops(EBL));
       printf("         See the global array EBL.\n");                         
    fi:
    RETURN(IDLIST):
end:
ramarobinsids[findtype10]:=proc(T)
 local T1,T2,T3,ABCOND,IDLIST,CS,n,p,c1,a,FF,FF2,EB,SYMF,nm,a1,a2,c2,p1,p2,
       COND1, COND2, pmf;
 local am2, pm2, dd1:
 global xprint,NEWJACID,RJID,SYMJID:
 global TT1,TT2,PROVEDFL10,EBL:
        if not(type(TT1,integer)) then
          TT1:=100:
          TT2:=400:
        fi:
        if not(type(xprint,boolean)) then
          xprint:=false:
        fi:
   T1:=TT2:
   T2:=trunc(9*TT2/10):
   T3:=trunc(8*TT2/10):
   EBL:=[]:
    IDLIST:=[]:
    PROVEDFL10:=[]:
    CS:={-1,1}:
    for n from 2 to T do
       nm:=modp(n,10):
       if xprint or nm=0 then
         lprint("n=",n);
       fi:
       for p1 in numtheory[divisors](n) do
       for p2 in numtheory[divisors](n) do
          for c1 in CS do
          for c2 in CS do
             a1:=n/p1:
             a2:=n/p2:
             ##HERE
             am2:=modp(a2,2):
             pm2:=modp(p2,2):
             dd1:=igcd(a1,p1):
             if a1>p1  and  a2>p2 and igcd(a1,a2,p1,p2)=1
             and not(member([a1/dd1,p1/dd1,c1],convert(myramtype1,set))) 
             ##and am2=0 and pm2=1
             then
                SYMF:=(_G(a1)*_H(p1) + c1 *_H(a1)*_G(p1))
                      /(_G(a2)*_HM(p2)+c2*_H(a2)*_GM(p2)):
                if xprint then
                   print(SYMF);
                fi:
                COND1:=GE(a1)+HE(p1)-HE(a1)-GE(p1):
                COND2:=GE(a2)+HE(p2)-HE(a2)-GE(p2):
                if type(COND1,integer) and type(COND2,integer) then
                   FF:=CHECKRAMIDF(SYMF,10,TT1):
                   if FF<>NULL then
                      FF2:=CHECKRAMIDF(SYMF,10,TT2):
                      if FF2<>NULL then
                        EB:=ebase:
RJID:=jacprodmake(series(jac2series(_JFUNC,3*EB+5)/q^LDQ,q,2*EB+10),q,2*EB+10)*q^LDQ;
                        SYMJID:=_JFUNC - RJID:
                        if proveit then
                           NEWJACID:=processjacid(SYMJID):
                           pmf:=provemodfuncidBATCH(NEWJACID,jmxperiod):
                           if pmf=1 then
PROVEDFL10:=[op(PROVEDFL10),[a1,p1,c1,a2,p2,c2,jmxperiod,mintottmp]]:
                           fi:
                        fi:
                        lprint([a1,p1,c1,a2,p2,c2]);
                        print(SYMID);
                        IDLIST:=[op(IDLIST),[a1,p1,c1,a2,p2,c2]]:
                      fi:
                   fi:
                fi:                                  
             fi:
          od:
          od:
       od:
       od:
    od:
    RETURN(IDLIST):
end:
 ramarobinsids[Geta]:=(g,d,n)->q^(n*QP2(g/d)*d/2)*JAC(n*g,n*d,infinity)/JAC(0,n*d,infinity);
 ramarobinsids[GetaB]:=(g,d,n)->JAC(n*g,n*d,infinity)/JAC(0,n*d,infinity);
 ramarobinsids[GetaEXP]:=(g,d,n)->n*QP2(g/d)*d/2;
 ramarobinsids[GetaL]:=(L,d,n)->mul(Geta(L[j],d,n),j=1..nops(L));
 ramarobinsids[GetaLB]:=(L,d,n)->mul(GetaB(L[j],d,n),j=1..nops(L));
 ramarobinsids[GetaLEXP]:=(L,d,n)->add(GetaEXP(g,d,n),g in L);
ramarobinsids[latexeta]:=proc(L)
  local a,b:
  ## latex print eta(L[1]*tau)^L[2]
  a:=L[1]: b:=L[2]:
  if a=1 and b=1 then
    printf("\\eta(\\tau)");
  fi:
  if a=1 and b>1 then
    printf("\\eta(\\tau)^{%a}",b);
  fi:
  if a>1 and b=1 then
    printf("\\eta(%a\\tau)",a);
  fi:
  if a>1 and b>1 then
    printf("\\eta(%a\\tau)^{%a}",a,b);
  fi:
RETURN():
end:
ramarobinsids[latexetaquot]:=proc(CN,LN,LD)
  local L:
  if CN<>1 then
    printf("{%a}\\,",CN);
  fi:
  printf("\\frac{");
  for L in LN do
    latexeta(L);
  od:
  printf("}{");
  for L in LD do
   latexeta(L);
  od:
  printf("}");
RETURN():
end:
ramarobinsids[latexpm]:=proc(c1)
   if c1 = 1 then
     printf(" + ");
   else
     printf(" - ");
   fi:
RETURN():
end:
ramarobinsids[latexprinttype1]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID:
  global _F:
  p:=L[1]:
  a:=L[2]:
  c1:=L[3]:
  N:=L[4]:          
  B:=L[5]:
  _F:=series(jac2series(G(p)*H(a) + c1*G(a)*H(p),2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
  if c1=1 then
   printf("G(%a)\\,H(%a) + G(%a)\\,H(%a) \&= \n",p,a,a,p);
  else
   printf("G(%a)\\,H(%a) - G(%a)\\,H(%a) \&= \n",p,a,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype2]:=proc(L, EQNNAME, num,nL)
  local a,p,c1,N,B,_LDQ,_RID:
  global _F:
##SYMF:=_G(a)*_G(p) + c1*_H(a)*_H(p):
##PROVEDFL2:=[op(PROVEDFL2),[a,p,c1,jmxperiod,mintottmp]]:
  a:=L[1]:
  p:=L[2]:
  c1:=L[3]:
  N:=L[4]:          
  B:=L[5]:
  _F:=series(jac2series(G(a)*G(p) + c1*H(a)*H(p),2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
  if c1=1 then
   printf("G(%a)\\,G(%a) + H(%a)\\,H(%a) \&= \n",a,p,a,p);
  else
   printf("G(%a)\\,G(%a) - H(%a)\\,H(%a) \&= \n",a,p,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype3]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID,_F0,a1,p1,a2,p2,c2:
  global _F:
##SYMF:=(_G(a1)*_G(p1) + c1 *_H(a1)*_H(p1))
##       /(_G(a2)*_H(p2)+c2*_H(a2)*_G(p2)):
##PROVEDFL3:=[op(PROVEDFL3),[a1,p1,c1,a2,p2,c2,jmxperiod,mintottmp]]:
##IDLIST:=[op(IDLIST),[a1,p1,c1,a2,p2,c2]]:
  a1:=L[1]:
  p1:=L[2]:
  c1:=L[3]:
  a2:=L[4]:
  p2:=L[5]:
  c2:=L[6]:
  N:=L[7]:          
  B:=L[8]:
  _F0:=(G(a1)*G(p1) + c1 *H(a1)*H(p1))
         /(G(a2)*H(p2)+c2*H(a2)*G(p2)):
  _F:=series(jac2series(_F0,2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
  printf("\\frac{");
  printf("G(%a)\\,G(%a)",a1,p1);
  latexpm(c1);
  printf("H(%a)\\,H(%a)",a1,p1);
  printf("}{");
  printf("G(%a)\\,H(%a)",a2,p2);
  latexpm(c2);
  printf("H(%a)\\,G(%a)}",a2,p2);
  printf(" \&= \n");
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype4]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID:
  global _F:
  p:=L[1]:
  a:=L[2]:
  c1:=L[3]:
  N:=L[4]:          
  B:=L[5]:
  _F:=series(jac2series(GM(p)*HM(a) + c1*GM(a)*HM(p),2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
if nL<1 then
  if c1=1 then
   printf("G^{*}(%a)\\,H^{*}(%a) + G^{*}(%a)\\,H^{*}(%a) \&= \n",p,a,a,p);
  else
   printf("G^{*}(%a)\\,H^{*}(%a) - G^{*}(%a)\\,H^{*}(%a) \&= \n",p,a,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
else
  if c1=1 then
   printf("G^{*}(%a)\\,H^{*}(%a) + G^{*}(%a)\\,H^{*}(%a) = \n",p,a,a,p);
  else
   printf("G^{*}(%a)\\,H^{*}(%a) - G^{*}(%a)\\,H^{*}(%a) = \n",p,a,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype5]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID:
  global _F:
  a:=L[1]:
  p:=L[2]:
  c1:=L[3]:
  N:=L[4]:          
  B:=L[5]:
  _F:=series(jac2series(GM(a)*GM(p) + c1*HM(a)*HM(p),2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
if nL>1 then
  if c1=1 then
   printf("G^{*}(%a)\\,G^{*}(%a) + H^{*}(%a)\\,H^{*}(%a) \&= \n",a,p,a,p);
  else
   printf("G^{*}(%a)\\,G^{*}(%a) - H^{*}(%a)\\,H^{*}(%a) \&= \n",a,p,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
else
  if c1=1 then
   printf("G^{*}(%a)\\,G^{*}(%a) + H^{*}(%a)\\,H^{*}(%a) = \n",a,p,a,p);
  else
   printf("G^{*}(%a)\\,G^{*}(%a) - H^{*}(%a)\\,H^{*}(%a) = \n",a,p,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype6]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID:
  global _F:
  a:=L[1]:
  p:=L[2]:
  c1:=L[3]:
  N:=L[4]:          
  B:=L[5]:
  _F:=series(jac2series(G(a)*HM(p) + c1*GM(a)*H(p),2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
if nL>1 then
  if c1=1 then
   printf("G(%a)\\,H^{*}(%a) + G^{*}(%a)\\,H(%a) \&= \n",a,p,a,p);
  else
   printf("G(%a)\\,H^{*}(%a) - G^{*}(%a)\\,H(%a) \&= \n",a,p,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
else
  if c1=1 then
   printf("G^{*}(%a)\\,G^{*}(%a) + H^{*}(%a)\\,H^{*}(%a) = \n",a,p,a,p);
  else
   printf("G^{*}(%a)\\,G^{*}(%a) - H^{*}(%a)\\,H^{*}(%a) = \n",a,p,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype7]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID:
  global _F:
  a:=L[1]:
  p:=L[2]:
  c1:=L[3]:
  N:=L[4]:          
  B:=L[5]:
  _F:=series(jac2series(GM(a)*G(p) + c1*HM(a)*H(p),2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
if nL<1 then
  if c1=1 then
   printf("G^{*}(%a)\\,G(%a) + H^{*}(%a)\\,H(%a) \&= \n",a,p,a,p);
  else
   printf("G^{*}(%a)\\,G(%a) - H^{*}(%a)\\,H(%a) \&= \n",a,p,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
else
  if c1=1 then
   printf("G^{*}(%a)\\,G(%a) + H^{*}(%a)\\,H(%a) = \n",a,p,a,p);
  else
   printf("G^{*}(%a)\\,G(%a) - H^{*}(%a)\\,H(%a) = \n",a,p,a,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype8]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID:
  global _F:
  p:=L[1]:
  c1:=L[2]:
  N:=L[3]:          
  B:=L[4]:
  _F:=series(jac2series(G(1)^p*H(p) + c1*H(1)^p*G(p),2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
if nL<1 then
  if c1=1 then
   printf("G(1)^{%a}\\,H(%a) + H(1)^{%a}\\,G(%a) \&= \n",p,p,p,p);
  else
   printf("G(1)^{%a}\\,H(%a) - H(1)^{%a}\\,G(%a) \&= \n",p,p,p,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
else
  if c1=1 then
   printf("G(1)^{%a}\\,H(%a) + H(1)^{%a}\\,G(%a) = \n",p,p,p,p);
  else
   printf("G(1)^{%a}\\,H(%a) - H(1)^{%a}\\,G(%a) = \n",p,p,p,p);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype9]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID,b,x:
  global _F:
  a:=L[1]:
  b:=L[2]:
  x:=L[3]:          
  N:=L[4]:
  B:=L[5]:
  _F:=series(jac2series(G(1)^a*H(1)^b - H(1)^a*G(1)^b-x,2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
if nL<1 then
  if x=0 then
   printf("G(1)^{%a}\\,H(1)^{%a} - H(1)^{%a}\\,G(1)^{%a} \&= \n",a,b,a,b);
  else
   printf("G(1)^{%a}\\,H(1)^{%a} - H(1)^{%a}\\,G(1)^{%a} - 1 \&= \n",a,b,a,b);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
else
  if x=0 then
   printf("G(1)^{%a}\\,H(1)^{%a} - H(1)^{%a}\\,G(1)^{%a} = \n",a,b,a,b);
  else
   printf("G(1)^{%a}\\,H(1)^{%a} - H(1)^{%a}\\,G(1)^{%a} - 1 = \n",a,b,a,b);
  fi: 
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttype10]:=proc(L, EQNNAME, num, nL)
  local a,p,c1,N,B,_LDQ,_RID,b,x,a1,p1,a2,p2,c2,_F0:
  global _F:
  a1:=L[1]:
  p1:=L[2]:
  c1:=L[3]:          
  a2:=L[4]:
  p2:=L[5]:
  c2:=L[6]:
  N:=L[7]:
  B:=L[8]:
  _F0:=(G(a1)*H(p1) + c1 *H(a1)*G(p1))
         /(G(a2)*HM(p2)+c2*H(a2)*GM(p2)):
  _F:=series(jac2series(_F0,2*N+10),q,2*N+8):
  _LDQ:= lqdegree(_F):
  _RID:=etamake(series(_F/q^_LDQ,q,2*N+8),q,trunc(9*N/5)+1)*q^_LDQ;
  ##print(_RID);
if nL>1 then
  printf("\\frac{");
  printf("G(%a)\\,H(%a)",a1,p1);
  latexpm(c1);
  printf("H(%a)\\,G(%a)",a1,p1);
  printf("}{");
  printf("G(%a)\\,H^{*}(%a)",a2,p2);
  latexpm(c2);
  printf("H(%a)\\,G^{*}(%a)}",a2,p2);
  printf(" \&= \n");
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
else
  printf("\\frac{");
  printf("G(%a)\\,H(%a)",a1,p1);
  latexpm(c1);
  printf("H(%a)\\,G(%a)",a1,p1);
  printf("}{");
  printf("G(%a)\\,H^{*}(%a)",a2,p2);
  latexpm(c2);
  printf("H(%a)\\,G^{*}(%a)}",a2,p2);
  printf(" = \n");
  if type(_RID,integer) then
    printf("%a\n",_RID);
  else
    latexetaquot(_etaconst,_etalisttop, _etalistbot);
  fi:
  if num < nL then
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a,\n",N,-B); 
     printf("\\mylabel{eq:%a}\\\\\n",cat(EQNNAME,num));
  else
     printf(",\\quad \\Gamma_1(%a), \\quad -B=%a.\n",N,-B); 
     printf("\\mylabel{eq:%a}\n",cat(EQNNAME,num));
  fi:
fi:
  ##printf(",\&\\quad \&\\Gamma_1(%a), \&\\quad -B=%a, \\\\\n",N,-B); 
  RETURN():
end:
ramarobinsids[latexprinttypeL1]:=proc(LL,EQNNAME,FILENAME)
local nLL,L,num:
nLL:=nops(LL):
writeto(FILENAME):
\printf("\\begin{alignat}{3}\n");
num:=0:
for L in LL do 
num:=num+1: 
latexprinttype1(L,EQNNAME,num,nLL); od:
\printf("\\end{alignat}\n");
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL2]:=proc(LL,EQNNAME,FILENAME)
local L,num,nLL:
nLL:=nops(LL):
writeto(FILENAME):
\printf("\\begin{alignat}{3}\n");
num:=0:
for L in LL do 
num:=num+1: 
latexprinttype2(L,EQNNAME,num,nLL); od:
\printf("\\end{alignat}\n");
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL3]:=proc(LL,EQNNAME,FILENAME)
local L,num,nLL:
writeto(FILENAME):
\printf("\\begin{alignat}{3}\n");
num:=0:
nLL:=nops(LL):
for L in LL do 
num:=num+1: 
latexprinttype3(L,EQNNAME,num,nLL); od:
\printf("\\end{alignat}\n");
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL4]:=proc(LL,EQNNAME,FILENAME)
local nLL,L,num:
nLL:=nops(LL):
writeto(FILENAME):
num:=0:
if nLL>1 then
   printf("\\begin{alignat}{3}\n");
   for L in LL do 
     num:=num+1: 
     latexprinttype4(L,EQNNAME,num,nLL); 
   od:
   printf("\\end{alignat}\n");
else
   printf("\\begin{equation}\n");
   latexprinttype4(LL[1],EQNNAME,1,1);
   printf("\\end{equation}\n");
fi:
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL5]:=proc(LL,EQNNAME,FILENAME)
local nLL,L,num:
nLL:=nops(LL):
writeto(FILENAME):
num:=0:
if nLL>1 then
   printf("\\begin{alignat}{3}\n");
   for L in LL do 
     num:=num+1: 
     latexprinttype5(L,EQNNAME,num,nLL); 
   od:
   printf("\\end{alignat}\n");
else
   printf("\\begin{equation}\n");
   latexprinttype5(LL[1],EQNNAME,1,1);
   printf("\\end{equation}\n");
fi:
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL6]:=proc(LL,EQNNAME,FILENAME)
local nLL,L,num:
nLL:=nops(LL):
writeto(FILENAME):
num:=0:
if nLL>1 then
   printf("\\begin{alignat}{3}\n");
   for L in LL do 
     num:=num+1: 
     latexprinttype6(L,EQNNAME,num,nLL); 
   od:
   printf("\\end{alignat}\n");
else
   printf("\\begin{equation}\n");
   latexprinttype6(LL[1],EQNNAME,1,1);
   printf("\\end{equation}\n");
fi:
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL7]:=proc(LL,EQNNAME,FILENAME)
local nLL,L,num:
nLL:=nops(LL):
writeto(FILENAME):
num:=0:
if nLL>1 then
   printf("\\begin{alignat}{3}\n");
   for L in LL do 
     num:=num+1: 
     latexprinttype7(L,EQNNAME,num,nLL); 
   od:
   printf("\\end{alignat}\n");
else
   printf("\\begin{equation}\n");
   latexprinttype7(LL[1],EQNNAME,1,1);
   printf("\\end{equation}\n");
fi:
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL8]:=proc(LL,EQNNAME,FILENAME)
local nLL,L,num:
nLL:=nops(LL):
writeto(FILENAME):
num:=0:
if nLL>1 then
   printf("\\begin{alignat}{3}\n");
   for L in LL do 
     num:=num+1: 
     latexprinttype8(L,EQNNAME,num,nLL); 
   od:
   printf("\\end{alignat}\n");
else
   printf("\\begin{equation}\n");
   latexprinttype8(LL[1],EQNNAME,1,1);
   printf("\\end{equation}\n");
fi:
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL9]:=proc(LL,EQNNAME,FILENAME)
local nLL,L,num:
nLL:=nops(LL):
writeto(FILENAME):
num:=0:
if nLL>1 then
   printf("\\begin{alignat}{3}\n");
   for L in LL do 
     num:=num+1: 
     latexprinttype9(L,EQNNAME,num,nLL); 
   od:
   printf("\\end{alignat}\n");
else
   printf("\\begin{equation}\n");
   latexprinttype9(LL[1],EQNNAME,1,1);
   printf("\\end{equation}\n");
fi:
writeto(terminal):
RETURN():
end:
ramarobinsids[latexprinttypeL10]:=proc(LL,EQNNAME,FILENAME)
local nLL,L,num:
nLL:=nops(LL):
writeto(FILENAME):
num:=0:
if nLL>1 then
   printf("\\begin{alignat}{3}\n");
   for L in LL do 
     num:=num+1: 
     latexprinttype10(L,EQNNAME,num,nLL); 
   od:
   printf("\\end{alignat}\n");
else
   printf("\\begin{equation}\n");
   latexprinttype10(LL[1],EQNNAME,1,1);
   printf("\\end{equation}\n");
fi:
writeto(terminal):
RETURN():
end:
ramarobinsids[MGeta]:=proc(g,d,n)
       local g2, d2:
       g2:=modp(g,2): d2:=modp(d,2):
       if g2=0 and d2=0 then
          RETURN(Geta(g,d,n)):
       fi:
       if g2=1 and d2=0 then
          q^GetaEXP(g,d,n)*JAC(2*n*g,2*n*d,infinity)/JAC(0,2*n*d,infinity)
          /JAC(n*g,n*d,infinity)*JAC(0,n*d,infinity):
          RETURN(%):
       fi:
       if g2=0 and d2=1 then
          q^GetaEXP(g,d,n)*JAC(n*g,2*n*d,infinity)/JAC(0,2*n*d,infinity)
          *JAC(2*n*g,2*n*d,infinity)/JAC(0,2*n*d,infinity)
          /JAC(n*g,n*d,infinity)*JAC(0,n*d,infinity)
          /JAC(2*n*g,4*n*d,infinity)*JAC(0,4*n*d,infinity)
          *JAC(n*g,2*n*d,infinity)/JAC(0,2*n*d,infinity):
	  RETURN(%):
       fi:
       if g2=1 and d2=1 then
          q^GetaEXP(g,d,n)*JAC(n*g,n*d,infinity)/JAC(0,n*d,infinity)
          *JAC(2*n*g,4*n*d,infinity)/JAC(0,4*n*d,infinity)
          /JAC(n*g,2*n*d,infinity)*JAC(0,2*n*d,infinity)
          /JAC(n*g,2*n*d,infinity)*JAC(0,2*n*d,infinity):
	  RETURN(%):
       fi:
end:
ramarobinsids[MGetaL]:=(L,d,n)->mul(MGeta(L[j],d,n),j=1..nops(L));
ramarobinsids[qnr]:=proc(p)
 local L,T,j:
    L:=[]:
    if modp(p,4)=1 then T:=(p-1)/2: else T:=p-1: fi:
    for j from 1 to T do
    if numtheory[legendre](j,p)=-1 then
    L:=[op(L),j]:
    fi:
    od:
 RETURN(L):
end:
ramarobinsids[qr]:=proc(p)
 local L,T,j:
    L:=[]:
    if modp(p,4)=1 then T:=(p-1)/2: else T:=p-1: fi:
    for j from 1 to T do
    if numtheory[legendre](j,p)=1 then
    L:=[op(L),j]:
    fi:
    od:
 RETURN(L):
end:
ramarobinsids[ramarobinsidspversion]:=proc()
printf("****************************************************\n");
printf("*\n");
printf("*  ramrobinsids package version 0.1  \n");
printf("*  Sat, Aug 06, 2016  3:58:35 PM\n");
printf("*  Previous version:            \n");
printf("*  Sat, Aug 06, 2016  3:58:35 PM\n");
printf("*  This version tested on MAPLE 2015\n"); 
printf("*\n");
printf("*  Please report any problems to fgarvan@ufl.edu\n");
printf("****************************************************\n");
RETURN():
end:
printf("TABLE TYPE ramarobinsids = %a\n",type(ramarobinsids,table));
savelib( ramarobinsids 
,
"c:\\cygwin64/home/fgarvan/maple/mylib/ramrobinsids.mla");
##"H:\\\\maple\\\\newmylib\\\\ramarobinsids.mla");
printf("END ramarobinsids package\n");
## mylib  above must be changed to the name of the directory
## in which you want stuff stored