Changeset 906feb in git


Ignore:
Timestamp:
Oct 16, 2013, 3:52:44 PM (9 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
Children:
7e075f9845dc22380591ebc0b5d48893f35119a7
Parents:
3630419158783d9329a9e0d3d501208a60c71b1093c5cfba000e32deb436c41555c925c987d90ab9
Message:
Merge pull request #402 from surface-smoothers/minGmpVersion

min required gmp version is 4.3.2  and no longer 3.1.1
Files:
43 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/derham.lib

    r93c5cf r906feb  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="";
    3 category="Noncommutative";
    4 info="
    5 LIBRARY:  derham.lib      Computation of deRham cohomology
    6 AUTHORS:  Cornelia Rottner, rottner@mathematik.uni-kl.de
    7 OVERVIEW:
    8 PROCEDURES:
    9 
    10 ";
    11 
    12 
    13 LIB "nctools.lib";
    14 LIB "matrix.lib";
    15 LIB "qhmoduli.lib";
    16 LIB "general.lib";
    17 LIB "dmod.lib";
    18 LIB "bfun.lib";
    19 LIB "dmodapp.lib";
    20 LIB "poly.lib";
    21 
    22 /////////////////////////////////////////////////////////////////////////////
    23 
    24 static proc divdr(matrix m, matrix n)
    25 {
    26   m=transpose(m);
    27   n=transpose(n);
    28   matrix con=concat(m,n);
    29   matrix s=syz(con);
    30   s=submat(s,1..ncols(m),1..ncols(s));
    31   s=transpose(compress(s));
    32   return(s);
    33 }
    34 
    35 /////////////////////////////////////////////////////////////////////////////
    36 
    37 
    38 static proc matrixlift(matrix M, matrix N)
    39 {
    40   // option(noreturnSB);
    41   matrix l=transpose(lift(transpose(M),transpose(N)));
    42   return(l);
    43 }
    44 
    45 ///////////////////////////////////////////////////////////////////////////////
    46 
    47 proc shortexactpieces(list #)
    48 {
    49   matrix  Bnew= divdr(#[2],#[3]);
    50   matrix Bold=Bnew;
    51   matrix Z=divdr(Bnew,#[1]);
    52   list bzh; list zcb;
    53   bzh=list(list(),list(),Z,unitmat(ncols(Z)),Z);
    54   zcb=(Z, Bnew, #[1], unitmat(ncols(#[1])), Bnew);
    55   list sep;
    56   sep[1]=(list(bzh,zcb));
    57   int i;
    58   list out;
    59   for (i=3; i<=size(#)-2; i=i+2)
    60     {
    61       out=bzhzcb(Bold, #[i-1] , #[i], #[i+1], #[i+2]);
    62       sep[size(sep)+1]=out[1];
    63       Bold=out[2];
    64     }
    65   bzh=(divdr(#[size(#)-2], #[size(#)-1]),#[size(#)-2], #[size(#)-1],unitmat(ncols(#[size(#)-1])),transpose(concat(transpose(#[size(#)-2]),transpose(#[size(#)-1]))));
    66   zcb=(#[size(#)-1], unitmat(ncols(#[size(#)-1])), #[size(#)-1],list(),list());
    67   sep[size(sep)+1]=list(bzh,zcb);
    68   return(sep);
    69 }
    70 
    71 ////////////////////////////////////////////////////////////////////////////////////////
    72 
    73 static proc bzhzcb (matrix Bold, matrix f0, matrix C1, matrix f1,matrix C2)
    74 {
    75   matrix Bnew=divdr(f1,C2);
    76   matrix Z= divdr(Bnew,C1);
    77   matrix lift1= matrixlift(Bnew,f0);
    78   list bzh=(Bold, lift1, Z, unitmat(ncols(Z)), transpose(concat(transpose(lift1),transpose(Z))));
    79   list zcb=(Z, Bnew, C1, unitmat(ncols(C1)),Bnew);
    80   list out=(list(bzh, zcb), Bnew);
    81   return(out);
    82 }
    83 
    84 //////////////////////////////////////////////////////////////////////////////////////
    85 
    86 proc VdstrictGB (matrix M, int d ,list #);
    87 "USAGE:VdstrictGB(M,d[,v]); M a matrix, d an integer, v an optional intvec(shift vector)
    88 RETURN:matrix M; the rows of M foem a Vd-strict Groebner basis for imM
    89 ASSUME:1<=d<=nvars(basering)/2; size(v)=ncols(M)
    90 "
    91 {
    92   if (M==matrix(0,nrows(M),ncols(M)))
    93     {
    94       return (matrix(0,1,ncols(M)));
    95     }
    96   def W =basering;
    97   int ncM=ncols(M);
    98   list Data=ringlist(W);
    99   Data[2]=list("nhv")+Data[2];
    100   Data[3][3]=Data[3][1];
    101   Data[3][1]=Data[3][2];
    102   Data[3][2]=list("dp",intvec(1));
    103   matrix re[size(Data[2])][size(Data[2])]=UpOneMatrix(size(Data[2]));
    104   Data[5]=re;
    105   int k; int l;
    106   Data[6]=transpose(concat(matrix(0,1,1),transpose(concat(matrix(0,1,1),Data[6]))));
    107   def Whom=ring(Data);
    108   setring Whom;
    109   matrix Mnew=imap(W,M);
    110   intvec v;
    111   if (size(#)!=0)
    112     {
    113       v=#[1];
    114     }
    115   if (size(v) < ncM)
    116     {
    117       v=v,0:(ncM-size(v));
    118     }
    119   Mnew=homogenize(Mnew, d, v);
    120   Mnew=transpose(Mnew);
    121   Mnew=std(Mnew);
    122   Mnew=subst(Mnew,nhv,1);
    123   Mnew=transpose(Mnew);
    124   setring W;
    125   M=imap(Whom,Mnew);
    126   return(M);
    127 }
    128 
    129 ////////////////////////////////////////////////////////////////////////////////////
    130 
    131 static proc Vdnormalform(matrix F, matrix M, int d, intvec v)
    132 {
    133   def W =basering;
    134   int c=ncols(M);
    135   F=submat(F,intvec(1..nrows(F)),intvec(1..c));
    136   list Data=ringlist(W);
    137   Data[2]=list("nhv")+Data[2];
    138   Data[3][3]=Data[3][1];
    139   Data[3][1]=Data[3][2];
    140   Data[3][2]=list("dp",intvec(1));
    141   matrix re[size(Data[2])][size(Data[2])]=UpOneMatrix(size(Data[2]));
    142   Data[5]=re;
    143   int k;
    144   int l;
    145   matrix rep[size(Data[2])][size(Data[2])];
    146   for (l=size(Data[2])-1;l>=1; l--)
    147     {
    148       for (k=l-1; k>=1;k--)
    149         {
    150           rep[k+1,l+1]=Data[6][k,l];
    151         }
    152     }
    153   Data[6]=rep;
    154   def Whom=ring(Data);
    155   setring Whom;
    156   matrix Mnew=imap(W,M);
    157   Mnew=(homogenize(Mnew, d, v));//doppelte Berechung unnötig->muss noch geändert werden!!!
    158   matrix Fnew=imap(W,F);
    159   matrix Fb;
    160   for (l=1; l<=nrows(Fnew); l++)
    161     {
    162       Fb=homogenize(submat(Fnew,l,intvec(1..ncols(Fnew))),d,v);
    163       Fb=transpose(reduce(transpose(Fb),std(transpose(Mnew))));// doppelte Berechnung unnötig, unterdrückt aber Fehler meldung
    164       for (k=1; k<=ncols(Fnew);k++)
    165         {
    166           Fnew[l,k]=Fb[1,k];
    167         }
    168     }
    169   Fnew=subst(Fnew,nhv,1);
    170   setring W;
    171   F=imap(Whom,Fnew);
    172   return(F);
    173 }
    174 
    175 
    176 ///////////////////////////////////////////////////////////////////////////////
    177 
    178 static proc homogenize (matrix M, int d, intvec v)
    179 {
    180   int l; poly f; int s; int i; intvec vnm;int kmin; list findmin;
    181   int n=(nvars(basering)-1) div 2;
    182   list rempoly;
    183   list remk;
    184   list rem1;
    185   list rem2;
    186   for (int k=1; k<=nrows(M); k++) //man könnte auch paralell immer weiter homogenisieren, d.h. immer ein enues Minimum finden und das dann machen
    187     {
    188       for (l=1; l<=ncols (M); l++)
    189         {
    190           f=M[k,l];
    191           s=size(f);
    192           for (i=1; i<=s; i++)
    193             {
    194               vnm=leadexp(f);
    195               vnm=vnm[n+2..n+d+1]-vnm[2..d+1];
    196               kmin=sum(vnm)+v[l];
    197               rem1[size(rem1)+1]=lead(f);
    198               rem2[size(rem2)+1]=kmin;
    199               findmin=insert(findmin,kmin);
    200               f=f-lead(f);
    201             }
    202           rempoly[l]=rem1;
    203           remk[l]=rem2;
    204           rem1=list();
    205           rem2=list();
    206         }
    207       if (size(findmin)!=0)
    208         {
    209           kmin=Min(findmin);
    210         }
    211       for (l=1; l<=ncols(M); l++)
    212         {
    213           if (M[k,l]!=0)
    214             {
    215               M[k,l]=0;
    216               for (i=1; i<=size(rempoly[l]);i++)
    217                 {
    218                   M[k,l]=M[k,l]+nhv^(remk[l][i]-kmin)*rempoly[l][i];
    219                 }
    220             }
    221         }
    222       rempoly=list();
    223       remk=list();
    224       findmin=list();
    225     }
    226   return(M);
    227 }
    228 
    229 
    230 //////////////////////////////////////////////////////////////////////////////////////
    231 
    232 static proc soldr (matrix M, matrix N)
    233 {
    234   int n=nrows(M);
    235   int q=ncols(M);
    236   matrix S=concat(transpose(M),transpose(N));
    237   def W=basering;
    238   list Data=ringlist(W);
    239   list Save=Data[3];
    240   Data[3]=list(list("c",0),list("dp",intvec(1..nvars(W))));
    241   def Wmod=ring(Data);
    242   setring Wmod;
    243   matrix Smod=imap(W,S);
    244   matrix E[q][1];
    245   matrix Smod2;
    246   matrix Smodnew;
    247   option(returnSB);
    248   int i; int j;
    249   for (i=1;i<=q;i++)
    250     {
    251       E[i,1]=1;
    252       Smod2=concat(E,Smod);
    253       print (Smod2);
    254       Smod2=syz(Smod2);
    255       E[i,1]=0;
    256       for (j=1;j<=ncols(Smod2);j++)
    257         {
    258           if (Smod2[1,j]==1)
    259             {
    260               Smodnew=concat(Smodnew,(-1)*(submat(Smod2,intvec(2..n+1),j)));
    261               break;
    262             }
    263         }
    264     }
    265   Smodnew=transpose(submat(Smodnew,intvec(1..n),intvec(2..q+1)));
    266   setring W;
    267   matrix  Snew=imap(Wmod,Smodnew);
    268   return (Snew);
    269 }
    270 
    271 
    272 /////////////////////////////////////////////////////////////////////////////
    273 
    274 proc toVdstrictsequence (list C,int n, intvec v)
    275 
    276 {
    277   matrix J_C=VdstrictGB(C[5],n,list(v));
    278   matrix J_A=C[1];
    279   matrix f_CB=C[4];
    280   matrix f_ACB=transpose(concat(transpose(C[2]),transpose(f_CB)));
    281   matrix J_AC=divdr(f_ACB,C[3]);
    282   matrix P=matrixlift(J_AC * prodr(ncols(C[1]),ncols(C[5])) ,J_C);
    283   list storePi;
    284   matrix Pi[1][ncols(J_AC)];
    285   int i;int j;
    286   for (i=1; i<=nrows(J_C); i++)
    287     {
    288       for (j=1; j<=nrows(J_AC);j++)
    289         {
    290           Pi=Pi+P[i,j]*submat(J_AC,j,intvec(1..ncols(J_AC)));
    291         }
    292       storePi[i]=Pi;
    293       Pi=0;
    294     }
    295   intvec m_a;
    296   list findMin;
    297   int comMin;
    298   for (i=1; i<=ncols(J_A); i++)
    299     {
    300       for (j=1; j<=size(storePi);j++)
    301         {
    302           if (storePi[j][1,i]!=0)
    303             {
    304               comMin=Vddeg(storePi[j]*prodr(ncols(J_A),ncols(C[5])),n,v)-Vddeg(storePi[j][1,i],n,intvec(0));
    305               findMin[size(findMin)+1]=comMin;
    306             }
    307         }
    308       if (size(findMin)!=0)
    309         {
    310           m_a[i]=Min(findMin);
    311           findMin=list();
    312         }
    313       else
    314         {
    315           m_a[i]=0;
    316         }
    317     }
    318   matrix zero[ncols(J_A)][ncols(J_C)];
    319 
    320   matrix g_AB=concat(unitmat(ncols(J_A)),zero);
    321   matrix g_BC= transpose(concat(transpose(zero),transpose(unitmat(ncols(J_C)))));
    322   intvec m_b=m_a,v;
    323 
    324   J_A=VdstrictGB(J_A,n,m_a);
    325   J_AC=transpose(storePi[1]);
    326   for (i=2; i<= size(storePi); i++)
    327     {
    328       J_AC=concat(J_AC, transpose(storePi[i]));
    329     }
    330   J_AC=transpose(concat(transpose(matrix(J_A,nrows(J_A),nrows(J_AC))),J_AC));
    331 
    332   list Vdstrict=(list(J_A),list(g_AB),list(J_AC),list(g_BC),list(J_C),list(m_a),list(m_b),list(v));
    333   return (Vdstrict);
    334 }
    335 
    336 
    337 /////////////////////////////////////////////////////////////////////////
    338 
    339 static proc prodr (int k, int l)
    340 {
    341   if (k==0)
    342     {
    343       matrix P=unitmat(l);
    344       return (P);
    345     }
    346   matrix O[l][k];
    347   matrix P=transpose(concat(O,unitmat(l)));
    348   return (P);
    349 }
    350 
    351 /////////////////////////////////////////////////////////////////////////
    352 
    353 proc Vddeg(matrix M, int d, intvec v, list #)//Aternative: in WHom Leadmonom ausrechnen!!
    354   "USAGE: Vddeg(M,d,v); M 1xr-matrix, d int, v intvec of size r
    355 RETURN:int; the Vd-degree of M
    356 "
    357 {
    358   int i;int j;
    359   int n=nvars(basering) div 2;
    360   intvec  e;
    361   int etoint;
    362   list findmax;
    363   int c=ncols(M);
    364   poly l;
    365   list positionpoly;
    366   list positionVd;
    367   for (i=1; i<=c; i++)
    368     {
    369       positionpoly[i]=list();
    370       positionVd[i]=list();
    371       while (M[1,i]!=0)
    372         {
    373           l=lead(M[1,i]);
    374           positionpoly[i][size(positionpoly[i])+1]=l;
    375           e=leadexp(l);
    376           e=-e[1..d]+e[n+1..n+d];
    377           e=sum(e)+v[i];
    378           etoint=e[1];
    379           positionVd[i][size(positionVd[i])+1]=etoint;
    380           findmax[size(findmax)+1]=etoint;
    381           M[1,i]=M[1,i]-l;
    382         }
    383     }
    384   if (size(findmax)!=0)
    385     {
    386       int maxVd=Max(findmax);
    387       if (size(#)==0)
    388         {
    389           return (maxVd);
    390         }
    391     }
    392   else // M is 0-modul
    393     {
    394       return(int(0));
    395     }
    396   l=0;
    397   for (i=c; i>=1; i--)
    398     {
    399       for (j=1; j<=size(positionVd[i]); j++)
    400         {
    401           if (positionVd[i][j]==maxVd)
    402             {
    403               l=l+positionpoly[i][j];
    404             }
    405         }
    406       if (l!=0)
    407         {
    408           return (list(l,i));
    409         }
    410     }
    411 
    412 }
    413 
    414 
    415 ///////////////////////////////////////////////////////////////////////////////
    416 
    417 proc toVdstrictsequences (list L,int d, intvec v)
    418   "USAGE: toVdstrictsequences(L,d,v); L list, d int, v intvec, L contains two lists of short exact sequences(D,f_DA,A,f_AF,F) and (A,f_AB,B,f_BC,C), v is a shift vector on the range of C
    419 RETURN: list of two lists; each lists contains Vd-strict exact sequences with corresponding shift vectors
    420 "
    421 {
    422   matrix J_F=L[1][5];
    423   matrix J_D=L[1][1];
    424   matrix f_FA=L[1][4];
    425   matrix f_DFA=transpose(concat(transpose(L[1][2]),transpose(f_FA)));
    426   matrix J_DF=divdr(f_DFA,L[1][3]);
    427   matrix J_C=L[2][5];
    428   matrix f_CB=L[2][4];
    429   matrix f_DFCB=transpose(concat(transpose(f_DFA*L[2][2]),transpose(f_CB)));
    430   matrix J_DFC=divdr(f_DFCB,L[2][3]);
    431   matrix P=matrixlift(J_DFC*prodr(ncols(J_DF),ncols(L[2][5])),J_C);
    432   list storePi;
    433   matrix Pi[1][ncols(J_DFC)];
    434   int i; int j;
    435   for (i=1; i<=nrows(J_C); i++)
    436     {
    437 
    438       for (j=1; j<=nrows(J_DFC);j++)
    439         {
    440           Pi=Pi+P[i,j]*submat(J_DFC,j,intvec(1..ncols(J_DFC)));
    441         }
    442       storePi[i]=Pi;
    443       Pi=0;
    444     }
    445   intvec m_a;
    446   list findMin;
    447   list noMin;
    448   int comMin;
    449   for (i=1; i<=ncols(J_DF); i++)
    450     {
    451       for (j=1; j<=size(storePi);j++)
    452         {
    453           if (storePi[j][1,i]!=0)
    454             {
    455               comMin=Vddeg(storePi[j]*prodr(ncols(J_DF),ncols(J_C)),d,v)-Vddeg(storePi[j][1,i],d,intvec(0));
    456               findMin[size(findMin)+1]=comMin;
    457             }
    458         }
    459       if (size(findMin)!=0)
    460         {
    461           m_a[i]=Min(findMin);
    462           findMin=list();
    463           noMin[i]=0;
    464         }
    465       else
    466         {
    467           noMin[i]=1;
    468         }
    469     }
    470   if (size(m_a) < ncols(J_DF))
    471     {
    472       m_a[ncols(J_DF)]=0;
    473     }
    474   intvec m_f=m_a[ncols(J_D)+1..size(m_a)];
    475   J_F=VdstrictGB(J_F,d,m_f);
    476   P=matrixlift(J_DF * prodr(ncols(L[1][1]),ncols(L[1][5])) ,J_F);// selbe Prinzip wie oben--> evtl auslagern
    477   list storePinew;
    478   matrix Pidf[1][ncols(J_DF)];
    479   for (i=1; i<=nrows(J_F); i++)
    480     {
    481       for (j=1; j<=nrows(J_DF);j++)
    482         {
    483           Pidf=Pidf+P[i,j]*submat(J_DF,j,intvec(1..ncols(J_DF)));
    484         }
    485       storePinew[i]=Pidf;
    486       Pidf=0;
    487     }
    488   intvec m_d;
    489   for (i=1; i<=ncols(J_D); i++)
    490     {
    491       for (j=1; j<=size(storePinew);j++)
    492         {
    493           if (storePinew[j][1,i]!=0)
    494             {
    495               comMin=Vddeg(storePinew[j]*prodr(ncols(J_D),ncols(L[1][5])),d,m_f)-Vddeg(storePinew[j][1,i],d,intvec(0));
    496               findMin[size(findMin)+1]=comMin;
    497             }
    498         }
    499       if (size(findMin)!=0)
    500         {
    501           if (noMin[i]==0)
    502             {
    503               m_d[i]=Min(insert(findMin,m_a[i]));
    504               m_a[i]=m_d[i];
    505             }
    506           else
    507             {
    508               m_d[i]=Min(findMin);
    509               m_a[i]=m_d[i];
    510             }
    511         }
    512       else
    513         {
    514           m_d[i]=m_a[i];
    515         }
    516       findMin=list();
    517     }
    518   J_D=VdstrictGB(J_D,d,m_d);
    519   J_DF=transpose(storePinew[1]);
    520   for (i=2; i<=nrows(J_F); i++)
    521     {
    522       J_DF=concat(J_DF,transpose(storePinew[i]));
    523     }
    524   J_DF=transpose(concat(transpose(matrix(J_D,nrows(J_D),nrows(J_DF))),J_DF));
    525   J_DFC=transpose(storePi[1]);
    526   for (i=2; i<=nrows(J_C); i++)
    527     {
    528       J_DFC=concat(J_DFC,transpose(storePi[i]));
    529     }
    530   J_DFC=transpose(concat(transpose(matrix(J_DF,nrows(J_DF),nrows(J_DFC))),J_DFC));
    531   intvec m_b=m_a,v;
    532   matrix zero[ncols(J_D)][ncols(J_F)];
    533   matrix g_DA=concat(unitmat(ncols(J_D)),zero);
    534   matrix g_AF=transpose(concat(transpose(zero),unitmat(ncols(J_F))));
    535   matrix zero1[ncols(J_DF)][ncols(J_C)];
    536   matrix g_AB=concat(unitmat(ncols(J_DF)),zero1);
    537   matrix g_BC=transpose(concat(transpose(zero1),unitmat(ncols(J_C))));
    538   list out=(list(list(J_D),list(g_DA),list(J_DF),list(g_AF),list(J_F),list(m_d),list(m_a),list(m_f)),list(list(J_DF),list(g_AB),list(J_DFC),list(g_BC),list(J_C),list(m_a),list(m_b),list(v)));
    539   return(out),
    540     }
    541 
    542 ///////////////////////////////////////////////////////////////////////////////////////////
    543 
    544 proc shortexactpiecestoVdstrict(list C, int d,list #)
    545 
    546 {
    547 
    548   int s =size(C);
    549   if (size(#)==0)
    550     {
    551       intvec v=0:ncols(C[s][1][5]);
    552     }
    553   else
    554     {
    555       intvec v=#[1];
    556     }
    557   list out;
    558   out[s]=list(toVdstrictsequence(C[s][1],d,v));
    559   out[s][2]=list(list(out[s][1][3][1]),list(unitmat(ncols(out[s][1][3][1]))),list(out[s][1][3][1]),list(list()),list(list()));
    560   out[s][2][6]=list(out[s][1][7][1]);
    561   out[s][2][7]=list(out[s][2][6][1]);
    562   out[s][2][8]=list(list());
    563   int i;
    564   for (i=s-1; i>=2; i--)
    565     {
    566       C[i][2][5]=out[i+1][1][1][1];
    567       out[i]=toVdstrictsequences(C[i],d,out[i+1][1][6][1]);
    568     }
    569   out[1]=list(list());
    570   out[1][2]=toVdstrictsequence(C[1][2],d,out[2][1][6][1]);
    571   out[1][1][3]=list(out[1][2][1][1]);
    572   out[1][1][5]=list(out[1][2][1][1]);
    573   out[1][1][4]=list(unitmat(ncols(out[1][1][3][1])));
    574   out[1][1][7]=list(out[1][2][6][1]);
    575   out[1][1][8]=list(out[1][2][6][1]);
    576   out[1][1][1]=list(list());
    577   out[1][1][2]=list(list());
    578   out[1][1][6]=list(list());
    579   list Hi;
    580   for (i=1; i<=size(out); i++)
    581     {
    582       Hi[i]=list(out[i][1][5][1],out[i][1][8][1]);
    583     }
    584   list outall;
    585   outall[1]=out;
    586   print (out);
    587   outall[2]=Hi;
    588   return(outall);
    589 
    590 
    591 }
    592 
    593 ///////////////////////////////////////////////////////////////////////////////////////////
    594 
    595 proc toVdstrict2x3complex(list L, int d, list #)
    596 {
    597   matrix rem; int i; int j;
    598   list J_A=list(list());
    599   list J_B=list(list());
    600   list J_C=list(list());
    601   list g_AB=list(list());
    602   list g_BC=list(list());
    603   list n_a=list(list());
    604   list n_b=list(list());
    605   list n_c=list(list());
    606   intvec n_b1;
    607   if (size(L[5])!=0)
    608     {
    609       intvec n_c1;
    610       for (i=1; i<=nrows(L[5]); i++)
    611         {
    612           rem=submat(L[5],i,intvec(1..ncols(L[5])));
    613           n_c1[i]=Vddeg(rem,d, L[8]);
    614         }
    615       n_c[1]=n_c1;
    616       J_C[1]=transpose(syz(transpose(L[5])));
    617       if (J_C[1]!=matrix(0,nrows(J_C[1]),ncols(J_C[1])))
    618         {
    619           J_C[1]=VdstrictGB(J_C[1],d,n_c1);
    620           if (size(#[2])!=0)
    621             {
    622               n_a[1]=#[2];
    623               n_b1=n_a[1],n_c[1];
    624               n_b[1]=n_b1;
    625               matrix zero[nrows(L[1])][nrows(L[5])];
    626               g_AB=concat(unitmat(nrows(L[1])),matrix(0,nrows(L[1]),nrows(L[5])));
    627               if (size(#[1])!=0)
    628                 {
    629                   J_A=#[1];
    630                   J_B=transpose(matrix(syz(transpose(L[3]))));
    631                   matrix P=matrixlift(J_B[1] * prodr(nrows(L[1]),nrows(L[5])) ,J_C[1]);
    632 
    633                   matrix Pi[1][ncols(J_B[1])];
    634                   matrix Picombined;
    635                   for (i=1; i<=nrows(J_C[1]); i++)
    636                     {
    637                       for (j=1; j<=nrows(J_B[1]);j++)
    638                         {
    639                           Pi=Pi+P[i,j]*submat(J_B[1],j,intvec(1..ncols(J_B[1])));
    640 
    641                         }
    642                       if (i==1)
    643                         {
    644                           Picombined=transpose(Pi);
    645                         }
    646                       else
    647                         {
    648                           Picombined=concat(Picombined,transpose(Pi));
    649                         }
    650                       Pi=0;
    651                     }
    652                   Picombined=transpose(Picombined);
    653                   Picombined=concat(Vdnormalform(Picombined,J_A[1],d,n_a[1]),submat(Picombined,intvec(1..nrows(Picombined)),intvec((ncols(J_A[1])+1)..ncols(Picombined))));
    654                   J_B[1]=transpose(concat(transpose(matrix(J_A[1],nrows(J_A[1]),ncols(J_B[1]))),transpose(Picombined)));
    655                   g_BC=transpose(concat(transpose(zero),unitmat(nrows(L[5]))));
    656                 }
    657               else
    658                 {
    659                   J_B[1]=concat(matrix(0,nrows(J_C[1]),nrows(L[3])-nrows(L[5])),J_C[1]);
    660                   g_BC=transpose(concat(transpose(zero),unitmat(nrows(L[5]))));
    661                 }
    662             }
    663           else
    664             {
    665               n_b=n_c[1];
    666               J_B[1]=J_C[1];
    667               g_BC=unitmat(ncols(J_C[1]));
    668             }
    669         }
    670       else
    671         {
    672           J_C=list(list());
    673           if (size(#[2])!=0)
    674             {
    675               matrix zero[nrows(L[1])][nrows(L[5])];
    676               g_BC=transpose(concat(transpose(zero),unitmat(nrows(L[5]))));
    677               n_a[1]=#[2];
    678               n_b1=n_a[1],n_c[1];
    679               n_b[1]=n_b1;
    680               g_AB=concat(unitmat(nrows(L[1])),matrix(0,nrows(L[1]),nrows(L[5])));;
    681 
    682               if (size(#[1])!=0)
    683                 {
    684                   J_A=#[1];
    685                   J_B=concat(J_A[1],matrix(0,nrows(J_A[1]),nrows(L[3])-nrows(L[1])));
    686                 }
    687             }
    688           else
    689             {
    690               n_b=n_c[1];
    691               g_BC=unitmat(ncols(L[5]));
    692             }
    693 
    694         }
    695     }
    696   else
    697     {
    698       if (size(#[2])!=0)
    699         {
    700           n_a[1]=#[2];
    701           n_b=n_a[1];
    702           g_AB=unitmat(size(n_b[1]));
    703           if (size(#[1])!=0)
    704             {
    705               J_A=#[1];
    706               J_B[1]=J_A[1];
    707             }
    708         }
    709     }
    710   list out=(J_A[1],g_AB[1],J_B[1],g_BC[1],J_C[1],n_a[1],n_b[1],n_c[1]);
    711   return (out);
    712 }
    713 
    714 
    715 //////////////////////////////////////////////////////////////////////////
    716 
    717 proc Vdstrictdoublecompexes(list L, int d)
    718 {
    719   int i; int k; int c; int j;
    720   intvec n_b;
    721   matrix rem;
    722   matrix J_B;
    723   list store;
    724   int t=size(L)+nvars(basering) div 2-2;
    725   for (k=1; k<=(size(L)+nvars(basering) div 2-3); k++)//
    726     {
    727       L[1][1][1][k+1]=list();
    728       L[1][1][2][k+1]=list();
    729       L[1][1][6][k+1]=list();
    730       if (size(L[1][1][3][k])!=0)
    731         {
    732           for (i=1; i<=nrows(L[1][1][3][k]); i++)
    733             {
    734               rem=submat(L[1][1][3][k],i,(1..ncols(L[1][1][3][k])));
    735               n_b[i]=Vddeg(rem,d,L[1][1][7][k]);
    736             }
    737           J_B=transpose(syz(transpose(L[1][1][3][k])));
    738           L[1][1][7][k+1]=n_b;
    739           L[1][1][8][k+1]=n_b;
    740           L[1][1][4][k+1]=unitmat(nrows(L[1][1][3][k]));
    741           if (J_B!=matrix(0,nrows(J_B),ncols(J_B)))
    742             {
    743               J_B=VdstrictGB(J_B,d,n_b);
    744               L[1][1][3][k+1]=J_B;
    745               L[1][1][5][k+1]=J_B;
    746             }
    747           else
    748             {
    749               L[1][1][3][k+1]=list();
    750               L[1][1][5][k+1]=list();
    751             }
    752           n_b=0;
    753         }
    754       else
    755         {
    756           L[1][1][3][k+1]=list();
    757           L[1][1][5][k+1]=list();
    758           L[1][1][7][k+1]=list();
    759           L[1][1][8][k+1]=list();
    760           L[1][1][4][k+1]=list();
    761         }
    762       for (i=1; i<size(L); i++)
    763         {
    764           store=toVdstrict2x3complex(list(L[i][2][1][k],L[i][2][2][k],L[i][2][3][k],L[i][2][4][k],L[i][2][5][k],L[i][2][6][k],L[i][2][7][k],L[i][2][8][k]),d,L[i][1][3][k+1],L[i][1][7][k+1]);
    765           for (j=1; j<=8; j++)
    766             {
    767               L[i][2][j][k+1]=store[j];
    768             }
    769 
    770           store=toVdstrict2x3complex(list(L[i+1][1][1][k],L[i+1][1][2][k],L[i+1][1][3][k],L[i+1][1][4][k],L[i+1][1][5][k],L[i+1][1][6][k],L[i+1][1][7][k],L[i+1][1][8][k]),d,L[i][2][5][k+1],L[i][2][8][k+1]);
    771 
    772           for (j=1; j<=8; j++)
    773             {
    774               L[i+1][1][j][k+1]=store[j];
    775             }
    776         }
    777       if (size(L[size(L)][1][7][k+1])!=0)
    778         {
    779           L[size(L)][2][4][k+1]=list();
    780           L[size(L)][2][5][k+1]=list();
    781           L[size(L)][2][6][k+1]=L[size(L)][1][7][k+1];
    782           L[size(L)][2][7][k+1]=L[size(L)][1][7][k+1];
    783           L[size(L)][2][8][k+1]=list();
    784           L[size(L)][2][2][k+1]=unitmat(size(L[size(L)][1][7][k+1]));
    785 
    786           if (size(L[size(L)][1][3][k+1])!=0)
    787             {
    788               L[size(L)][2][1][k+1]=L[size(L)][1][3][k+1];
    789               L[size(L)][2][3][k+1]=L[size(L)][1][3][k+1];
    790             }
    791           else
    792             {
    793               L[size(L)][2][1][k+1]=list();
    794               L[size(L)][2][3][k+1]=list();
    795             }
    796         }
    797       else
    798         {
    799           for (j=1; j<=8; j++)
    800             {
    801               L[size(L)][2][j][k+1]=list();
    802             }
    803         }
    804     }
    805 
    806 
    807   k=t;
    808   intvec n_c;
    809   intvec vn_b;
    810   list N_b;
    811   int n;
    812   for (i=1; i<=size(L); i++)
    813     {
    814       for (n=1; n<=2; n++)
    815         {
    816           if (i==1 and n==1)
    817             {
    818               L[i][n][6][k+1]=list();
    819             }
    820           else
    821             {
    822               if (n==1)
    823                 {
    824                   L[i][1][6][k+1]=L[i-1][2][8][k+1];
    825                 }
    826               else
    827                 {
    828                   L[i][2][6][k+1]=L[i][1][7][k+1];
    829                 }
    830             }
    831           N_b[1]=L[i][n][6][k+1];
    832           if (size(L[i][n][5][k])!=0)
    833             {
    834               for (j=1; j<=nrows(L[i][n][5][k]); j++)
    835                 {
    836                   rem=submat(L[i][n][5][k],j,(1..ncols(L[i][n][5][k])));
    837                   n_c[j]=Vddeg(rem,d,L[i][n][8][k]);
    838                 }
    839               L[i][n][8][k+1]=n_c;
    840             }
    841           else
    842             {
    843               L[i][n][8][k+1]=list();
    844             }
    845           N_b[2]=L[i][n][8][k+1];
    846           n_c=0;
    847           if (size(N_b[1])!=0)
    848             {
    849               vn_b=N_b[1];
    850               if (size(N_b[2])!=0)
    851                 {
    852                   vn_b=vn_b,N_b[2];
    853                 }
    854               L[i][n][7][k+1]=vn_b;
    855             }
    856           else
    857             {
    858               if (size(N_b[2])!=0)
    859                 {
    860                   L[i][n][7][k+1]=N_b[2];
    861                 }
    862               else
    863                 {
    864                   L[i][n][7][k+1]=list();
    865                 }
    866             }
    867 
    868         }
    869     }
    870   return(L);
    871 }
    872 
    873 ////////////////////////////////////////////////////////////////////////////
    874 
    875 proc assemblingdoublecomplexes(list L)
    876 {
    877   list out;
    878   int i; int j;int k;int l; int oldj; int newj;
    879   for (i=1; i<=size(L); i++)
    880     {
    881       out[i]=list(list());
    882       out[i][1][1]=ncols(L[i][2][3][1]);
    883       if (size(L[i][2][5][1])!=0)
    884         {
    885           out[i][1][4]=prodr(ncols(L[i][2][3][1])-ncols(L[i][2][5][1]),ncols(L[i][2][5][1]));
    886         }
    887       else
    888         {
    889           out[i][1][4]=matrix(0,ncols(L[i][2][3][1]),1);
    890         }
    891 
    892       oldj=newj;
    893       for (j=1; j<=size(L[i][2][3]);j++)
    894         {
    895           out[i][j][2]=L[i][2][7][j];
    896           if (size(L[i][2][3][j])==0)
    897             {
    898               newj =j;
    899               break;
    900             }
    901           out[i][j+1]=list();
    902           out[i][j+1][1]=nrows(L[i][2][3][j]);
    903           out[i][j+1][3]=L[i][2][3][j];
    904           if (size(L[i][2][5][j])!=0)
    905             {
    906               out[i][j+1][4]=(-1)^j*prodr(nrows(L[i][2][3][j])-nrows(L[i][2][5][j]),nrows(L[i][2][5][j]));
    907             }
    908           else
    909             {
    910               out[i][j+1][4]=matrix(0,nrows(L[i][2][3][j]),1);
    911             }
    912           if(j==size(L[i][2][3]))
    913             {
    914               out[i][j+1][2]=L[i][2][7][j+1];
    915               newj=j+1;
    916             }
    917         }
    918       if (i>1)
    919         {
    920           for (k=1; k<=Min(list(oldj,newj)); k++)
    921             {
    922               out[i-1][k][4]=matrix(out[i-1][k][4],nrows(out[i-1][k][4]),out[i][k][1]);
    923             }
    924           for (k=newj+1; k<=oldj; k++)
    925             {
    926               out[i-1][k]=delete(out[i-1][k],4);
    927             }
    928         }
    929     }
    930   return (out);
    931 }
    932 
    933 //////////////////////////////////////////////////////////////////////////////
    934 
    935 proc totalcomplex(list L);
    936 {
    937   list out;intvec rem1;intvec v; list remsize; int emp;
    938   int i; int j; int c; int d; matrix M; int k; int l;
    939   int n=nvars(basering) div 2;
    940   list K;
    941   for (i=1; i<=n; i++)
    942     {
    943       K[i]=list();
    944     }
    945   L=K+L;
    946   for (i=1; i<=size(L); i++)
    947     {
    948       emp=0;
    949       if (size(L[i])!=0)
    950         {
    951           out[3*i-2]=L[i][1][1];
    952           v=L[i][1][1];
    953           rem1=L[i][1][2];
    954           emp=1;
    955         }
    956       else
    957         {
    958           out[3*i-2]=0;
    959           v=0;
    960         }
    961 
    962       for (j=i+1; j<=size(L); j++)
    963         {
    964           if (size(L[j])>=j-i+1)
    965             {
    966               out[3*i-2]=out[3*i-2]+L[j][j-i+1][1];
    967               if (emp==0)
    968                 {
    969                   rem1=L[j][j-i+1][2];
    970                   emp=1;
    971                 }
    972               else
    973                 {
    974                   rem1=rem1,L[j][j-i+1][2];
    975                 }
    976               v[size(v)+1]=L[j][j-i+1][1];
    977             }
    978           else
    979             {
    980               v[size(v)+1]=0;
    981             }
    982         }
    983       out[3*i-1]=rem1;
    984       v[size(v)+1]=0;
    985       remsize[i]=v;
    986     }
    987   int o1;
    988   int o2;
    989   for (i=1; i<=size(L)-1; i++)
    990     {
    991       o1=1;
    992       o2=1;
    993       if (size(out[3*i-2])!=0)
    994         {
    995           o1=out[3*i-2];
    996         }
    997       if (size(out[3*i+1])!=0)
    998         {
    999           o2=out[3*i+1];
    1000         }
    1001       M=matrix(0,o1,o2);
    1002       if (size(L[i])!=0)
    1003         {
    1004           if (size(L[i][1][4])!=0)
    1005             {
    1006               M=matrix(L[i][1][4],o1,o2);
    1007             }
    1008         }
    1009       c=remsize[i][1];
    1010       // d=remsize[i+1][1];
    1011       for (j=i+1; j<=size(L); j++)
    1012         {
    1013           if (remsize[i][j-i+1]!=0)
    1014             {
    1015               for (k=c+1; k<=c+remsize[i][j-i+1]; k++)
    1016                 {
    1017                   for (l=d+1; l<=d+remsize[i+1][j-i];l++)
    1018                     {
    1019                       M[k,l]=L[j][j-i+1][3][(k-c),(l-d)];
    1020                     }
    1021                 }
    1022               d=d+remsize[i+1][j-i];
    1023               if (remsize[i+1][j-i+1]!=0)
    1024                 {
    1025                   for (k=c+1; k<=c+remsize[i][j-i+1]; k++)
    1026                     {
    1027                       for (l=d+1; l<=d+remsize[i+1][j-i+1];l++)
    1028                         {
    1029                           M[k,l]=L[j][j-i+1][4][k-c,l-d];
    1030                         }
    1031                     }
    1032                   c=c+remsize[i][j-i+1];
    1033                 }
    1034             }
    1035           else
    1036             {
    1037               d=d+remsize[i+1][j-i];
    1038             }
    1039         }
    1040       out[3*i]=M;
    1041       d=0; c=0;
    1042     }
    1043   out[3*size(L)]=matrix(0,out[3*size(L)-2],1);
    1044   return (out);
    1045 }
    1046 
    1047 /////////////////////////////////////////////////////////////////////////////////////
    1048 
    1049 proc toVdstrictfreecomplex(list L,list #)
    1050 {
    1051   def B=basering;
    1052   int n=nvars(B) div 2+2;
    1053   int d=nvars(B) div 2;
    1054   intvec v;
    1055   list out;list outall;
    1056   int i;int j;
    1057   matrix mem;
    1058   int k;
    1059   if (size(#)!=0)
    1060     {
    1061       for (i=1; i<=size(#); i++)
    1062         {
    1063           if (typeof(#[i])==intvec)
    1064             {
    1065               v=#[i];
    1066             }
    1067           if (typeof(#[i])==int)
    1068             {
    1069               d=#[i];
    1070             }
    1071         }
    1072     }
    1073   if (size(L)==2)
    1074     {
    1075       v=(0:ncols(L[1]));
    1076       out[3*n-1]=v;
    1077       out[3*n-2]=ncols(L[1]);
    1078       out[3*n]=L[2];
    1079       out[3*n-3]=VdstrictGB(L[1],d,v);
    1080       for (i=n-1; i>=1; i--)
    1081         {
    1082           out[3*i-2]=nrows(out[3*i]);
    1083           v=0;
    1084           for (j=1; j<=out[3*i-2]; j++)
    1085             {
    1086               mem=submat(out[3*i],j,intvec(1..ncols(out[3*i])));
    1087               v[j]=Vddeg(mem,d, out[3*i+2]);
    1088             }
    1089           out[3*i-1]=v;
    1090           if (i!=1)
    1091             {
    1092               out[3*i-3]=transpose(syz(transpose(out[3*i])));
    1093               if (out[3*i-3]!=matrix(0,nrows(out[3*i-3]),ncols(out[3*i-3])))
    1094                 {
    1095                   out[3*i-3]=VdstrictGB(out[3*i-3],d,out[3*i-1]);
    1096                 }
    1097               else
    1098                 {
    1099                   out[3*i-3]=matrix(0,1,ncols(out[3*i-3]));
    1100                   out[3*i-4]=intvec(0);
    1101                   out[3*i-5]=int(0);
    1102                   for (j=i-2; j>=1; j--)
    1103                     {
    1104                       out[3*j]=matrix(0,1,1);
    1105                       out[3*j-1]=intvec(0);
    1106                       out[3*j-2]=int(0);
    1107                     }
    1108                   break;
    1109                 }
    1110             }
    1111         }
    1112       outall[1]=out;
    1113       outall[2]=list(list(out[3*n-3],out[3*n-1]));
    1114       return(outall);
    1115     }
    1116   out=shortexactpieces(L);
    1117   list rem;
    1118   if (v!=intvec(0:size(v)))
    1119     {
    1120       rem=shortexactpiecestoVdstrict(out,d,v);
    1121     }
    1122   else
    1123     {
    1124       rem=shortexactpiecestoVdstrict(out,d);
    1125     }
    1126   out=Vdstrictdoublecompexes(rem[1],d);
    1127   out=assemblingdoublecomplexes(out);
    1128   out=totalcomplex(out);
    1129   outall[1]=out;
    1130   outall[2]=rem[2];
    1131   return (outall);
    1132 }
    1133 
    1134 ////////////////////////////////////////////////////////////////////////////////
    1135 
    1136 proc derhamcohomology(list L)
    1137 {
    1138   def R=basering;
    1139   int n=nvars(R);int le=2*size(L)+n-1;
    1140   def W=makeWeyl(n);
    1141   setring W;
    1142   list man=ringlist(W);
    1143   if (n==1)
    1144     {
    1145       man[2][1]="x(1)";
    1146       man[2][2]="D(1)";
    1147       def Wi=ring(man);
    1148       setring Wi;
    1149       kill W;
    1150       def W=Wi;
    1151       setring W;
    1152       list man=ringlist(W);
    1153     }
    1154   man[2][size(man[2])+1]="s";;
    1155   man[3][3]=man[3][2];
    1156   man[3][2]=list("dp",intvec(1));
    1157   matrix N=UpOneMatrix(size(man[2]));
    1158   man[5]=N;
    1159   matrix M[1][1];
    1160   man[6]=transpose(concat(transpose(concat(man[6],M)),M));
    1161   def Ws=ring(man); setring R;  int r=size(L); int i;  int j;int k; int l; int count;  list Fi; list subsets; list maxnum; list bernsteinpolys; list annideals; list minint; list diffmaps;
    1162   for (i=1; i<=r; i++)
    1163     {
    1164       Fi[i]=list(); bernsteinpolys[i]=list(); annideals[i]=list(); subsets[i]=list();
    1165       maxnum[i]=list();
    1166       Fi[1][i]=L[i];
    1167       maxnum[1][i]=i;
    1168       subsets[1][i]=intvec(i);
    1169     }
    1170   intvec v;
    1171   for (i=2; i<=r; i++)
    1172     {
    1173       count=1;
    1174       for (j=1; j<=size(Fi[i-1]);j++)
    1175         {
    1176           for (k=maxnum[i-1][j]+1; k<=r; k++)
    1177             {
    1178               maxnum[i][count]=k;
    1179               v=subsets[i-1][j],k;
    1180               subsets[i][count]=v;
    1181               Fi[i][count]=lcm(Fi[i-1][j],L[k]);/////////
    1182               count=count+1;
    1183             }
    1184         }
    1185     }
    1186   for (i=1; i<=r; i++)
    1187     {
    1188       for (j=1; j<=size(Fi[i]); j++)
    1189         {
    1190           bernsteinpolys[i][j]=bfct(Fi[i][j])[1];
    1191           for (k=1; k<=ncols(bernsteinpolys[i][j]); k++)
    1192             {
    1193               if (isInt(number(bernsteinpolys[i][j][k]))==1)
    1194                 {
    1195                   minint[size(minint)+1]=int(bernsteinpolys[i][j][k]);
    1196                 }
    1197             }
    1198           def D=Sannfs(Fi[i][j]);
    1199           setring Ws;
    1200           annideals[i][j]=fetch(D,LD);
    1201           kill D;
    1202           setring R;
    1203         }
    1204     }
    1205   int m=Min(minint);
    1206   list zw;
    1207   for (i=1; i<r; i++)
    1208     {
    1209       diffmaps[i]=matrix(0,size(subsets[i]),size(subsets[i+1]));
    1210       for (j=1; j<=size(subsets[i]); j++)
    1211         {
    1212           for (k=1; k<=size(subsets[i+1]); k++)
    1213             {
    1214               zw=mysubset(subsets[i][j],subsets[i+1][k]);
    1215               diffmaps[i][j,k]=zw[2]*(L[zw[1]]/gcd(L[zw[1]],Fi[i][j]))^(-m);
    1216             }
    1217         }
    1218     }
    1219   diffmaps[r]=matrix(0,1,1);
    1220   setring Ws;
    1221   for (i=1; i<=r; i++)
    1222     {
    1223       for (j=1; j<=size(annideals[i]); j++)
    1224         {
    1225           annideals[i][j]=subst(annideals[i][j],s,m);
    1226         }
    1227     }
    1228   setring W;
    1229   list annideals=imap(Ws,annideals);
    1230   list diffmaps=fetch(R,diffmaps);
    1231   list fortoVdstrict;
    1232   ideal IFourier=var(n+1);
    1233   for (i=2;i<=n;i++)
    1234     {
    1235       IFourier=IFourier,var(n+i);
    1236     }
    1237   for (i=1; i<=n;i++)
    1238     {
    1239       IFourier=IFourier,-var(i);
    1240     }
    1241   map cFourier=W,IFourier;
    1242   matrix sup;
    1243   for (i=1; i<=r; i++)
    1244     {
    1245       sup=matrix(annideals[i][1]);
    1246       fortoVdstrict[2*i-1]=transpose(cFourier(sup));
    1247       for (j=2; j<=size(annideals[i]); j++)
    1248         {
    1249           sup=matrix(annideals[i][j]);
    1250           fortoVdstrict[2*i-1]=dsum(fortoVdstrict[2*i-1],transpose(cFourier(sup)));
    1251         }
    1252       sup=diffmaps[i];
    1253       fortoVdstrict[2*i]=cFourier(sup);
    1254     }
    1255   list rem=toVdstrictfreecomplex(fortoVdstrict);
    1256   list newcomplex=rem[1];
    1257   list minmaxk=globalbfun(rem[2]);
    1258   if (size(minmaxk)==0)
    1259     {
    1260       return (0);
    1261     }
    1262   list truncatedcomplex; list shorten; list  upto;
    1263   for (i=1; i<=size(newcomplex) div 3; i++)
    1264     {
    1265       shorten[3*i-1]=list();
    1266       for (j=1; j<=size(newcomplex[3*i-1]); j++)
    1267         {
    1268           shorten[3*i-1][j]=list(minmaxk[1]-newcomplex[3*i-1][j]+1,minmaxk[2]-newcomplex[3*i-1][j]+1);
    1269           upto[size(upto)+1]=shorten[3*i-1][j][2];
    1270           if (shorten[3*i-1][j][2]<=0)
    1271             {
    1272               shorten[3*i-1][j]=list();
    1273             }
    1274           else
    1275             {
    1276               if (shorten[3*i-1][j][1]<=0)
    1277                 {
    1278                   shorten[3*i-1][j][1]=1;
    1279                 }
    1280             }
    1281         }
    1282     }
    1283   int iupto=Max(upto);
    1284   if (iupto<=0)
    1285     {
    1286       /////die Kohomologie ist dann überall 0, muss noch entsprechend ausgegeben werden
    1287     }
    1288   list allpolys;
    1289   allpolys[1]=list(1);
    1290   list minvar;
    1291   minvar[1]=list(1);
    1292   for (i=1; i<=iupto-1; i++)
    1293     {
    1294       allpolys[i+1]=list();
    1295       minvar[i+1]=list();
    1296       for (k=1; k<=size(allpolys[i]); k++)
    1297         {
    1298           for (j=minvar[i][k]; j<=nvars(W) div 2; j++)
    1299             {
    1300               allpolys[i+1][size(allpolys[i+1])+1]=allpolys[i][k]*D(j);
    1301               minvar[i+1][size(minvar[i+1])+1]=j;
    1302             }
    1303         }
    1304     }
    1305   list keepformatrix;list sizetruncom;int stc;list fortrun;
    1306   for (i=1; i<=size(newcomplex) div 3; i++)
    1307     {
    1308       truncatedcomplex[2*i-1]=list();
    1309       sizetruncom[2*i-1]=list();
    1310       sizetruncom[2*i]=list();
    1311       truncatedcomplex[2*i]=newcomplex[3*i];
    1312       v=0;count=0;
    1313       sizetruncom[2*i][1]=0;
    1314       for (j=1; j<=newcomplex[3*i-2]; j++)
    1315         {
    1316           if (size(shorten[3*i-1][j])!=0)
    1317             {
    1318               fortrun=sublist(allpolys,shorten[3*i-1][j][1],shorten[3*i-1][j][2]);
    1319               truncatedcomplex[2*i-1][size(truncatedcomplex[2*i-1])+1]=fortrun[1];
    1320               count=count+fortrun[2];
    1321               sizetruncom[2*i-1][size(sizetruncom[2*i-1])+1]=list(int(shorten[3*i-1][j][1])-1,int(shorten[3*i-1][j][2])-1);
    1322               sizetruncom[2*i][size(sizetruncom[2*i])+1]=count;
    1323               if (v!=0)
    1324                 {
    1325                   v[size(v)+1]=j;
    1326                 }
    1327               else
    1328                 {
    1329                   v[1]=j;
    1330                 }
    1331             }
    1332         }
    1333 
    1334       if (v!=0)
    1335         {
    1336           truncatedcomplex[2*i]=submat(truncatedcomplex[2*i],v,1..ncols(truncatedcomplex[2*i]));
    1337           if (i!=1)
    1338             {
    1339               truncatedcomplex[2*(i-1)]=submat(truncatedcomplex[2*(i-1)],1..nrows(truncatedcomplex[2*(i-1)]),v);
    1340             }
    1341         }
    1342       else
    1343         {
    1344           truncatedcomplex[2*i]=matrix(0,1,ncols(truncatedcomplex[2*i]));
    1345           if (i!=1)
    1346             {
    1347               truncatedcomplex[2*(i-1)]=matrix(0,nrows(truncatedcomplex[2*(i-1)]),1);
    1348             }
    1349         }
    1350     }
    1351   int b;int d;poly form;poly lform; poly nform;int ideg;int kplus; int lplus;
    1352   for (i=1; i<size(truncatedcomplex) div 2; i++)
    1353     {
    1354       M=matrix(0,max(1,sizetruncom[2*i][size(sizetruncom[2*i])]),sizetruncom[2*i+2][size(sizetruncom[2*i+2])]);
    1355       for (k=1; k<=size(truncatedcomplex[2*i-1]);k++)
    1356         {
    1357           for (l=1; l<=size(truncatedcomplex[2*(i+1)-1]); l++)
    1358             {
    1359               if (size(sizetruncom[2*i])!=1)//?
    1360                 {
    1361                   for (j=1; j<=size(truncatedcomplex[2*i-1][k]); j++)
    1362                     {
    1363                       for (b=1; b<=size(truncatedcomplex[2*i-1][k][j]); b++)
    1364                         {
    1365                           form=truncatedcomplex[2*i-1][k][j][b][1]*truncatedcomplex[2*i][k,l];
    1366                           while (form!=0)
    1367                             {
    1368                               lform=lead(form);
    1369                               v=leadexp(lform);
    1370                               v=v[1..n];
    1371                               if (v==(0:n))
    1372                                 {
    1373                                   ideg=deg(lform)-sizetruncom[2*(i+1)-1][l][1];
    1374                                   if (ideg>=0)
    1375                                     {
    1376                                       for (d=1; d<=size(truncatedcomplex[2*(i+1)-1][l][ideg+1]);d++)
    1377                                         {
    1378                                           if (leadmonom(lform)==truncatedcomplex[2*(i+1)-1][l][ideg+1][d][1])
    1379                                             {
    1380                                               M[sizetruncom[2*i][k]+truncatedcomplex[2*i-1][k][j][b][2],sizetruncom[2*(i+1)][l]+truncatedcomplex[2*(i+1)-1][l][ideg+1][d][2]]=leadcoef(lform);
    1381                                               break;
    1382                                             }
    1383                                         }
    1384                                     }
    1385                                 }
    1386                               form=form-lform;
    1387                             }
    1388                         }
    1389                     }
    1390                 }
    1391             }
    1392         }
    1393       truncatedcomplex[2*i]=M;
    1394       truncatedcomplex[2*i-1]=sizetruncom[2*i][size(sizetruncom[2*i])];
    1395     }
    1396   truncatedcomplex[2*i-1]=sizetruncom[2*i][size(sizetruncom[2*i])];
    1397   if (truncatedcomplex[2*i-1]!=0)
    1398     {
    1399       truncatedcomplex[2*i]=matrix(0,truncatedcomplex[2*i-1],1);
    1400     }
    1401   setring R;
    1402   list truncatedcomplex=imap(W,truncatedcomplex);
    1403   list derhamhom=findhomology(truncatedcomplex,le);
    1404   return (derhamhom);
    1405 }
    1406 
    1407 ///////////////////////////////////
    1408 static proc sublist(list L, int m, int n)
    1409 {
    1410   list out;
    1411   int i; int j;
    1412   int count;
    1413   for (i=m; i<=n; i++)
    1414     {
    1415       out[size(out)+1]=list();
    1416       for (j=1; j<=size(L[i]); j++)
    1417         {
    1418           count=count+1;
    1419           out[size(out)][j]=list(L[i][j],count);
    1420         }
    1421     }
    1422   list o=list(out,count);
    1423   return(o);
    1424 }
    1425 
    1426 //////////////////////////////////////////////////////////////////////////
    1427 static proc mysubset(intvec L, intvec M)
    1428 {
    1429   int i;
    1430   int j=1;
    1431   list position=(M[size(M)],(-1)^(size(L)));
    1432   for (i=1; i<=size(L); i++)
    1433     {
    1434       if (L[i]!=M[j])
    1435         {
    1436           if (L[i]!=M[j+1] or j!=i)
    1437             {
    1438               return (L[i],0);
    1439             }
    1440           else
    1441             {
    1442               position=(M[i],(-1)^(i-1));
    1443               j=j+i;
    1444             }
    1445         }
    1446       j=j+1;
    1447     }
    1448   return (position);
    1449 }
    1450 
    1451 
    1452 
    1453 ////////////////////////////////////////////////////////////////////////////
    1454 
    1455 proc globalbfun(list L)
    1456 {
    1457   int i; int j;
    1458   def W=basering;
    1459   int n=nvars(W) div 2;
    1460   list G0;
    1461   ideal I;
    1462   for (j=1; j<=size(L); j++)
    1463     {
    1464       G0[j]=list();
    1465       for (i=1; i<=ncols(L[j][1]); i++)
    1466         {
    1467           G0[j][i]=I;
    1468         }
    1469     }
    1470   list out;
    1471   for (j=1; j<=size(L); j++)
    1472     {
    1473       for (i=1; i<=nrows(L[j][1]); i++)
    1474         {
    1475           out=Vddeg(submat(L[j][1],i,(1..ncols(L[j][1]))),n,L[j][2],1);
    1476           G0[j][out[2]][size(G0[j][out[2]])+1]=(out[1]);
    1477         }
    1478     }
    1479   list Data=ringlist(W);
    1480   for (i=1; i<=n; i++)
    1481     {
    1482       Data[2][2*n+i]=Data[2][i];
    1483       Data[2][3*n+i]=Data[2][n+i];
    1484       Data[2][i]="v("+string(i)+")";
    1485       Data[2][n+i]="w("+string(i)+")";
    1486     }
    1487   Data[3][1][1]="M";
    1488   intvec mord=(0:16*n^2);
    1489   mord[1..2*n]=(1:2*n);
    1490   mord[6*n+1..8*n]=(1:2*n);
    1491   for (i=0; i<=2*n-2; i++)
    1492     {
    1493       mord[(3+i)*4*n-i]=-1;
    1494       mord[(2*n+2+i)*4*n-2*n-i]=-1;
    1495     }
    1496   Data[3][1][2]=mord;//ordering mh?????????
    1497   matrix Ones=UpOneMatrix(4*n);
    1498   Data[5]=Ones;
    1499   matrix con[2*n][2*n];
    1500   Data[6]=transpose(concat(con,transpose(concat(con,Data[6]))));
    1501 
    1502   def Wuv=ring(Data);
    1503   setring Wuv;
    1504   list G0=imap(W,G0); list G3; poly lterm;intvec lexp;
    1505   list G1;  list G2; intvec e; intvec f; int  kapp; int k; int l; poly h; ideal I;
    1506   for (l=1; l<=size(G0); l++)
    1507     {
    1508       G1[l]=list();  G2[l]=list(); G3[l]=list();
    1509       for (i=1; i<=size(G0[l]); i++)
    1510         {
    1511           for (j=1; j<=ncols(G0[l][i]);j++)
    1512             {
    1513               G0[l][i][j]=mhom(G0[l][i][j]);
    1514             }
    1515           for (j=1; j<=nvars(Wuv) div 4; j++)
    1516             {
    1517               G0[l][i][size(G0[l][i])+1]=1-v(j)*w(j);
    1518             }
    1519           G1[l][i]=std(G0[l][i]);
    1520           G2[l][i]=I;
    1521           G3[l][i]=list();
    1522           for (j=1; j<=ncols(G1[l][i]); j++)
    1523             {
    1524               e=leadexp(G1[l][i][j]);
    1525               f=e[1..2*n];
    1526               if (f==intvec(0:(2*n)))
    1527                 {
    1528                   for (k=1; k<=n; k++)
    1529                     {
    1530                       kapp=-e[2*n+k]+e[3*n+k];
    1531                       if (kapp>0)
    1532                         {
    1533                           G1[l][i][j]=(x(k)^kapp)*G1[l][i][j];
    1534                         }
    1535                       if (kapp<0)
    1536                         {
    1537                           G1[l][i][j]=(D(k)^(-kapp))*G1[l][i][j];
    1538                         }
    1539                     }
    1540                   G2[l][i][size(G2[l][i])+1]=G1[l][i][j];
    1541                   G3[l][i][size(G3[l][i])+1]=list();
    1542                   while (G1[l][i][j]!=0)
    1543                     {
    1544                       lterm=lead(G1[l][i][j]);
    1545                       G1[l][i][j]=G1[l][i][j]-lterm;
    1546                       lexp=leadexp(lterm);
    1547                       lexp=lexp[2*n+1..3*n];
    1548                       G3[l][i][size(G3[l][i])][size(G3[l][i][size(G3[l][i])])+1]=list(lexp,leadcoef(lterm));
    1549                     }
    1550 
    1551                 }
    1552             }
    1553         }
    1554     }
    1555   ring r=0,(s(1..n)),dp;
    1556   ideal I;
    1557   map G3forr=Wuv,I;
    1558   list G3=G3forr(G3);
    1559   poly fs;
    1560   poly gs;
    1561   int a;
    1562   list G4;
    1563   for (l=1; l<=size(G3); l++)
    1564     {
    1565       G4[l]=list();
    1566       for (i=1; i<=size(G3[l]);i++)
    1567         {
    1568           G4[l][i]=I;
    1569           for (j=1; j<=size(G3[l][i]); j++)
    1570             {
    1571               fs=0;
    1572               for (k=1; k<=size(G3[l][i][j]); k++)
    1573                 {
    1574                   gs=1;
    1575                   for (a=1; a<=n; a++)
    1576                     {
    1577                       if (G3[l][i][j][k][1][a]!=0)
    1578                         {
    1579                           gs=gs*permutevar(list(G3[l][i][j][k][1][a]),a);
    1580                         }
    1581                     }
    1582                   gs=gs*G3[l][i][j][k][2];
    1583                   fs=fs+gs;
    1584                 }
    1585               G4[l][i]=G4[l][i],fs;
    1586             }
    1587         }
    1588     }
    1589   if (n==1)
    1590     {
    1591       ring rnew=0,t,dp;
    1592     }
    1593   else
    1594     {
    1595       ring rnew=0,(t,s(2..n)),dp;
    1596     }
    1597   ideal Iformap;
    1598   Iformap[1]=t;
    1599    poly forel=1;
    1600    for (i=2; i<=n; i++)
    1601      {
    1602        Iformap[1]=Iformap[1]-s(i);
    1603        Iformap[i]=s(i);
    1604        forel=forel*s(i);
    1605      }
    1606    map rtornew=r,Iformap;
    1607    list G4=rtornew(G4);
    1608    list getintvecs=fetch(W,L);
    1609    ideal J;
    1610    option(redSB);
    1611    for (l=1; l<=size(G4); l++)
    1612      {
    1613        J=1;
    1614        for (i=1; i<=size(G4[l]); i++)
    1615          {
    1616            G4[l][i]=eliminate(G4[l][i],forel);
    1617            G4[l][i]=subst(G4[l][i],t,t-getintvecs[l][2][i]);
    1618            J=intersect(J,G4[l][i]);
    1619          }
    1620        G4[l]=poly(std(J)[1]);
    1621      }
    1622    list minmax=minmaxintroot(G4);//besser factorize nehmen
    1623    // Fall: keine Nullstelle muss noch weiter beruecksichtigt werden
    1624   return(minmax);
    1625 }
    1626 
    1627 
    1628 
    1629 
    1630 //////////////////////////////////////////////////////////////////////////
    1631 
    1632 proc minmaxintroot(list L);
    1633 {
    1634   int i; int j; int k; int l; int sa; int s; number d; poly f; poly rest; list a0; list possk; list alldiv; intvec e;
    1635   possk[1]=list();
    1636   for (i=1; i<=size(L); i++)
    1637     {
    1638       d=1;
    1639       f=L[i];
    1640       while (f!=0)
    1641         {
    1642           rest=lead(f);
    1643           d=d*denominator(leadcoef(rest));
    1644           f=f-rest;
    1645         }
    1646       e=leadexp(rest);
    1647       if (e[1]!=0)
    1648         {
    1649           rest=rest/(t^(e[1]));
    1650           possk[1][size(possk[1])+1]=i;
    1651         }
    1652       a0[i]=int(absValue(d*rest));
    1653     }
    1654   int m=Max(a0);
    1655   for (i=2; i<=m+1; i++)
    1656     {
    1657       possk[i]=list();
    1658     }
    1659   list allprimefac;
    1660   for (i=1; i<=size(L); i++)
    1661     {
    1662       allprimefac=primefactors(a0[i]);
    1663       alldiv=1;
    1664       possk[2][size(possk[2])+1]=i;
    1665 
    1666       for (j=1; j<=size(allprimefac[1]); j++)
    1667         {
    1668           s=size(alldiv);
    1669           for (k=1; k<=s; k++)
    1670             {
    1671               for (l=1; l<=allprimefac[2][j]; l++)
    1672                 {
    1673                   alldiv[size(alldiv)+1]=alldiv[k]*allprimefac[1][j]^l;
    1674                   possk[alldiv[size(alldiv)]+1][size(possk[alldiv[size(alldiv)]+1])+1]=i;
    1675                 }
    1676             }
    1677         }
    1678     }
    1679   int mink;
    1680   int maxk;
    1681   int indi;
    1682   for (i=m+1; i>=1; i--)
    1683     {
    1684       if (size(possk[i])!=0)
    1685         {
    1686           for (j=1; j<=size(possk[i]); j++)
    1687             {
    1688               if (subst(L[possk[i][j]],t,(i-1))==0)
    1689                 {
    1690                   maxk=i-1;
    1691                   indi=1;
    1692                   break;
    1693                 }
    1694             }
    1695         }
    1696       if (maxk!=0)
    1697         {
    1698           break;
    1699         }
    1700     }
    1701   int indi2;
    1702   for (i=m+1; i>=1; i--)
    1703     {
    1704       if (size(possk[i])!=0)
    1705         {
    1706           for (j=1; j<=size(possk[i]); j++)
    1707             {
    1708               if (subst(L[possk[i][j]],t,-(i-1))==0)
    1709                 {
    1710                   mink=-i+1;
    1711                   indi2=1;
    1712                   break;
    1713                 }
    1714             }
    1715         }
    1716       if (mink!=0)
    1717         {
    1718           break;
    1719         }
    1720     }
    1721   list mima=mink,maxk;
    1722   if (indi==0)
    1723     {
    1724       if (indi2==0)
    1725         {
    1726           mima=list();//es gibt keine ganzzahlige NS
    1727         }
    1728       else
    1729         {
    1730           mima[2]=mima[1];
    1731         }
    1732     }
    1733   else
    1734     {
    1735       if (indi2==0)
    1736         {
    1737           mima[1]=mima[2];
    1738         }
    1739     }
    1740   return (mima);
    1741 }
    1742 
    1743 ///////////////////////////////////////////////////////
    1744 
    1745 
    1746 proc findhomology(list L, int le)
    1747 {
    1748   int li;
    1749   matrix M; matrix N;
    1750   matrix N1;
    1751   matrix lift1;
    1752   list out;
    1753   int i;
    1754   option (redSB);
    1755   for (i=2; i<=size(L); i=i+2)
    1756     {
    1757       if (L[i-1]==0)
    1758         {
    1759           li=0;
    1760           out[i div 2]=0;
    1761         }
    1762       else
    1763         {
    1764 
    1765           if (li==0)
    1766             {
    1767 
    1768 
    1769               li=L[i-1];
    1770               N1=transpose(syz(transpose(L[i])));
    1771               out[i div 2]=matrix(transpose(syz(transpose(N1))));
    1772               out[i div 2]=transpose(matrix(std(transpose(out[i div 2]))));
    1773 
    1774             }
    1775 
    1776           else
    1777             {
    1778 
    1779 
    1780               li=L[i-1];
    1781               N1=transpose(syz(transpose(L[i])));
    1782               N=transpose(syz(transpose(N1)));
    1783               lift1=matrixlift(N1,L[i-2]);
    1784               out[i div 2]=transpose(concat(transpose(lift1),transpose(N)));
    1785               out[i div 2]=transpose(matrix(std(transpose(out[i div 2]))));
    1786             }
    1787         }
    1788       if (out[i div 2]!=matrix(0,1,ncols(out[i div 2])))
    1789         {
    1790           out[i div 2]=ncols(out[i div 2])-nrows(out[i div 2]);
    1791         }
    1792       else
    1793         {
    1794           out[i div 2]=ncols(out[i div 2]);
    1795         }
    1796     }
    1797   if (size(out)>le)
    1798     {
    1799       out=delete(out,1);
    1800     }
    1801   return(out);
    1802 }
    1803 
    1804 
    1805 
    1806 
    1807 /////////////////////////////////////////////////////////////////////
    1808 
    1809 static proc mhom(poly f)
    1810 {
    1811   poly g;
    1812   poly l;
    1813   poly add;
    1814   intvec e;
    1815   list minint;
    1816   list remf;
    1817   int i;
    1818   int j;
    1819   int n=nvars(basering) div 4;
    1820   if (f==0)
    1821     {
    1822       return(f);
    1823     }
    1824   while (f!=0)
    1825     {
    1826       l=lead(f);
    1827       e=leadexp(l);
    1828       remf[size(remf)+1]=list();
    1829       remf[size(remf)][1]=l;
    1830       for (i=1; i<=n; i++)
    1831         {
    1832           remf[size(remf)][i+1]=-e[2*n+i]+e[3*n+i];
    1833           if (size(minint)<i)
    1834             {
    1835               minint[i]=list();
    1836             }
    1837           minint[i][size(minint[i])+1]=-e[2*n+i]+e[3*n+i];
    1838         }
    1839       f=f-l;
    1840     }
    1841   for (i=1; i<=n; i++)
    1842     {
    1843       minint[i]=Min(minint[i]);
    1844     }
    1845   for (i=1; i<=size(remf); i++)
    1846     {
    1847       add=remf[i][1];
    1848       for (j=1; j<=n; j++)
    1849         {
    1850           add=v(j)^(remf[i][j+1]-minint[j])*add;
    1851         }
    1852       g=g+add;
    1853     }
    1854   return (g);
    1855 }
    1856 
    1857 
    1858 
    1859 
    1860 //////////////////////////////////////////////////////////////////////////
    1861 
    1862 static proc permutevar(list L,int n)
    1863 {
    1864   if (typeof(L[1])=="intvec")
    1865     {
    1866       intvec v=L[1];
    1867     }
    1868   else
    1869     {
    1870       intvec v=(1:L[1]),(0:L[1]);
    1871     }
    1872   int i;int k; int indi=0;
    1873   int j;
    1874   int s=size(v);
    1875   poly e;
    1876   intvec fore;
    1877   for (i=2; i<=size(v); i=i+2)
    1878     {
    1879       if (v[i]!=0)
    1880         {
    1881           j=i+1;
    1882           while (v[j]!=0)
    1883             {
    1884               j=j+1;
    1885             }
    1886           v[i]=0;
    1887           v[j]=1;
    1888           fore=0;
    1889           indi=0;
    1890           for (k=1; k<=size(v); k++)
    1891             {
    1892               if (k!=i and k!=j)
    1893                 {
    1894                   if (indi==0)
    1895                     {
    1896                       indi=1;
    1897                       fore[1]=v[k];
    1898                     }
    1899                   else
    1900                     {
    1901                       fore[size(fore)+1]=v[k];
    1902                     }
    1903                 }
    1904             }
    1905           e=e-(j-i)*permutevar(list(fore),n);
    1906         }
    1907     }
    1908   e=e+s(n)^(size(v) div 2);
    1909   return (e);
    1910 }
    1911 
    1912 ///////////////////////////////////////////////////////////////////////////////
    1913 static proc max(int i,int j)
    1914 {
    1915   if(i>j){return(i);}
    1916   return(j);
    1917 }
    1918 
    1919 ////////////////////////////////////////////////////////////////////////////////////
    1920 version="$Id$";
     2version="version derham.lib 4.0.0.0 Jun_2013 ";
    19213category="Noncommutative";
    19224info="
     
    195436LIB "qhmoduli.lib";
    195537LIB "general.lib";
    1956 LIB "dmod.lib";
     38//LIB "dmod.lib";
    195739LIB "bfun.lib";
    195840LIB "dmodapp.lib";
     
    2643725             annihilators we computed for L[i]  ->this will ensure  we can compute
    2644726             the maps of the MV complex*/
    2645           minroot=minIntRoot(findminintroot);
     727          minroot=minIntRootD(findminintroot);
    2646728          for (j=1; j<=i; j++)
    2647729            {
     
    2729811                   s-parametric annihilators we computed for L[i]  ->this will
    2730812                   ensure  we can compute the maps of the MV complex*/
    2731               minroot=minIntRoot(findminintroot);
     813              minroot=minIntRootD(findminintroot);
    2732814              for (j=1; j<=i; j++)
    2733815                {
     
    29691051    }
    29701052  def B=basering;
    2971   int n=nvars(B) div 2 + 1;//+1 müsste stimmen! bitte kontrollieren!
     1053  int n=nvars(B) div 2 + 1;//+1 muesste stimmen! bitte kontrollieren!
    29721054  int d=nvars(B) div 2;
    29731055  int r=size(L) div 2;
     
    32661348  matrix zerom;
    32671349  list rofA;
    3268   for (i=3; i<=n+3; i++)////////////////////////////////////////////////////////////////////////////n und si müssen noch definiert werden
     1350  for (i=3; i<=n+3; i++)////////////////////////////////////////////////////////////////////////////n und si muessen noch definiert werden
    32691351    {
    32701352      if (size(RES)>=i)
     
    57963878                component of submat(L[j][1],i,(1..ncols(L[j][1])))*/
    57973879              i1=(1..ncols(L[j][1]));
    5798               out=VdDegTilde(submat(L[j][1],i,i1),n,intvec(0:size(L[j][2])),1);//hier könnte es evtl noch einen Fehler geben!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     3880              out=VdDegTilde(submat(L[j][1],i,i1),n,intvec(0:size(L[j][2])),1);//hier koennte es evtl noch einen Fehler geben!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    57993881              f=L[j][1][i,out[2]];
    58003882              if (out[2]==1)
     
    61484230   for (i=1; i<=size(G4); i++)
    61494231     {
    6150        minmax[i]=minIntRoot(G4[i],1);
     4232       minmax[i]=minIntRootD(G4[i],1);
    61514233       if (size(minmax[i])!=0)
    61524234         {
     
    61964278          else
    61974279            {
    6198               out[i div 2]=0;////achtung geändert??????????????????????????????????????????????????!!!!!!!!!!!!!!!!!!!!!!!!!war mal out[i-1]
     4280              out[i div 2]=0;////achtung geaendert??????????????????????????????????????????????????!!!!!!!!!!!!!!!!!!!!!!!!!war mal out[i-1]
    61994281              im=L[i-1];
    62004282            }
     
    65344616              and submat(Fnew,l,intvec(1..ncols(Fnew)))!=zeromat)
    65354617            {
    6536               //print("Reduzierung des V_d-Grades nötig");
     4618              //print("Reduzierung des V_d-Grades noetig");
    65374619              /*We need to reduce the V_d-degree. First we homogenize the
    65384620                lth row of Fnew*/
     
    74495531////////////////////////////////////////////////////////////////////////////////////
    74505532
    7451 static proc minIntRoot(list L,list #)
    7452 "USAGE:minIntRoot(L [,M]); L list, M optinonal list
     5533static proc minIntRootD(list L,list #)
     5534"USAGE:minIntRootD(L [,M]); L list, M optinonal list
    74535535ASSUME:L a list of univariate polynomials with rational coefficients @*
    74545536       the variable of the polynomial is s if size(#)==0 (needed for proc
  • Singular/LIB/help.cnf

    r93c5cf r906feb  
    2121#  %i: the complete path of singular.hlp
    2222#  %n: the info node
     23#  %v: Singular version (in the form 4-0-0)
    2324#----------------------------------------------------
    2425# the default help browsers builtin, dummy and emacs are always
     
    4243info!xiE:info:!info -f %i --node='%n'
    4344lynx!xhE:lynx:!lynx %h
     45#----------------------------------------------------------------
     46# dummy versions for pure online help
     47mac-www!E:open:O:ix86Mac-darwin:!open http://www.singular.uni-kl.de/Manual/%v/ &
     48mac-www!E:open:O:ppcMac-darwin:!open http://www.singular.uni-kl.de/Manual/%v/ &
     49mozilla-www!DE:mozilla:!(mozilla -remote "openURL(http://www.singular.uni-kl.de/Manual/%v/)")||(mozilla http://www.singular.uni-kl.de/Manual/%v/) &
     50firefox-www!DE:firefox:!firefox http://www.singular.uni-kl.de/Manual/%v/ &
     51konqueror-www!DE:konqueror:!konqueror http://www.singular.uni-kl.de/Manual/%v/ &
     52galeon-www!DE:galeon:!galeon -n http://www.singular.uni-kl.de/Manual/%v/ &
     53netscape-www!DE:netscape:!(netscape -remote "openURL(http://www.singular.uni-kl.de/Manual/%v/)")||(netscape http://www.singular.uni-kl.de/Manual/%v/) &
     54safari-www!E:/Applications/Safari.app:!open /Applications/Safari.app http://www.singular.uni-kl.de/Manual/%v/
     55lynx-www!E:lynx:!lynx http://www.singular.uni-kl.de/Manual/%v/
    4456
  • Singular/LIB/realclassify.lib

    r93c5cf r906feb  
    2828";
    2929
     30LIB "linalg.lib";
    3031LIB "elim.lib";
    3132LIB "primdec.lib";
     
    475476USAGE:    realmorsesplit(f[, mu]); f poly, mu int
    476477RETURN:   a list consisting of the corank of f, the inertia index, an upper
    477           bound for the determinacy, the residual form of f and
    478           the transformation
     478          bound for the determinacy, and the residual form of f
    479479NOTE:     The characteristic of the basering must be zero, the monomial order
    480480          must be local, f must be contained in maxideal(2) and the Milnor
     
    486486EXAMPLE:  example morsesplit; shows an example"
    487487{
    488   /* auxiliary variables */
    489   int i, j;
     488  int i;
    490489
    491490  /* error check */
     
    532531  }
    533532
    534   /* preliminary stuff */
    535   list S;
     533  /* compute the determinacy */
    536534  int k = determinacy(f, mu);
    537535  f = jet(f, k);
    538   def br = basering;
    539   map Phi = br, maxideal(1);
    540   map phi;
    541   poly a, p, r;
    542 
    543   /* treat the variables one by one */
     536
     537  /* get jet(f, 2) right */
     538  matrix H = concat(jet(jacob(jacob(f)), 0)/2, unitmat(n));
     539  H = sym_reduce(H);
     540  intvec perm_zero;
     541  intvec perm_neg;
     542  intvec perm_pos;
     543  int c;
     544  int lambda;
    544545  for(i = 1; i <= n; i++)
    545546  {
    546     if(jet(f, 2)/var(i) == 0)
    547     {
    548       S = insert(S, i);
    549     }
    550     else
    551     {
    552       f, a, p, r = rewriteformorsesplit(f, k, i);
    553       if(jet(a, 0) == 0)
    554       {
    555         for(j = i+1; j <= n; j++)
    556         {
    557           if(jet(f, 2)/(var(i)*var(j)) != 0)
    558           {
    559             break;
    560           }
    561         }
    562         phi = br, maxideal(1);
    563         phi[j] = var(j)+var(i);
    564         Phi = phi(Phi);
    565         f = phi(f);
    566       }
    567       f, a, p, r = rewriteformorsesplit(f, k, i);
    568       while(p != 0)
    569       {
    570         phi = br, maxideal(1);
    571         phi[i] = var(i)-p/(2*jet(a, 0));
    572         Phi = phi(Phi);
    573         f = phi(f);
    574         f, a, p, r = rewriteformorsesplit(f, k, i);
    575       }
    576     }
    577   }
    578 
    579   /* sort variables according to corank */
    580   int cr = size(S);
    581   phi = br, 0:n;
    582   j = 1;
    583   for(i = size(S); i > 0; i--)
    584   {
    585     phi[S[i]] = var(j);
    586     j++;
    587   }
     547    if(H[i, i] == 0)
     548    {
     549      perm_zero = perm_zero, i;
     550      c++;
     551    }
     552    if(H[i, i] < 0)
     553    {
     554      perm_neg = perm_neg, i;
     555      lambda++;
     556    }
     557    if(H[i, i] > 0)
     558    {
     559      perm_pos = perm_pos, i;
     560    }
     561  }
     562  intvec perm;
     563  if(size(perm_zero) > 1)
     564  {
     565    perm = perm, perm_zero[2..size(perm_zero)];
     566  }
     567  if(size(perm_neg) > 1)
     568  {
     569    perm = perm, perm_neg[2..size(perm_neg)];
     570  }
     571  if(size(perm_pos) > 1)
     572  {
     573    perm = perm, perm_pos[2..size(perm_pos)];
     574  }
     575  perm = perm[2..size(perm)];
     576  matrix T[n][n];
     577  matrix D[1][n];
    588578  for(i = 1; i <= n; i++)
    589579  {
    590     if(phi[i] == 0)
    591     {
    592       phi[i] = var(j);
    593       j++;
    594     }
    595   }
    596   Phi = phi(Phi);
     580    T[1..n, i] = H[perm[i], (n+1)..(2*n)];
     581    D[1, i] = H[perm[i], perm[i]];
     582  }
     583  map phi = basering, matrix(maxideal(1))*transpose(T);
    597584  f = phi(f);
    598 
    599   /* compute the inertia index lambda */
    600   int lambda;
    601   list negCoeff, posCoeff;
    602   number ai;
    603   poly f2 = jet(f, 2);
    604   for(i = 1; i <= n; i++)
    605   {
    606     ai = number(f2/var(i)^2);
    607     if(ai < 0)
    608     {
    609       lambda++;
    610       negCoeff = insert(negCoeff, i);
    611     }
    612     if(ai > 0)
    613     {
    614       posCoeff = insert(posCoeff, i);
    615     }
    616   }
    617 
    618   /* sort variables according to lambda */
    619   phi = br, maxideal(1);
    620   j = cr+1;
    621   for(i = size(negCoeff); i > 0; i--)
    622   {
    623     phi[negCoeff[i]] = var(j);
    624     j++;
    625   }
    626   for(i = size(posCoeff); i > 0; i--)
    627   {
    628     phi[posCoeff[i]] = var(j);
    629     j++;
    630   }
    631   Phi = phi(Phi);
    632   f = phi(f);
    633 
    634   /* compute residual form */
    635   phi = br, maxideal(1);
    636   for(i = size(S)+1; i <= n; i++)
    637   {
    638     phi[i] = 0;
    639   }
    640   f = phi(f);
    641 
    642   return(list(cr, lambda, k, f, Phi));
     585  f = jet(f, k);
     586
     587  /* separate the variables */
     588  phi = basering, maxideal(1);
     589  map corank_part = basering, maxideal(1);
     590  for(i = c+1; i <= n; i++)
     591  {
     592    corank_part[i] = 0;
     593  }
     594  poly h = f-jet(f, 2)-corank_part(f);
     595  poly hi;
     596  while(h != 0)
     597  {
     598    for(i = c+1; i <= n; i++)
     599    {
     600      hi = h/var(i);
     601      phi[i] = var(i)-hi/(2*D[1, i]);
     602      h = h-hi*var(i);
     603    }
     604    f = phi(f);
     605    f = jet(f, k);
     606    h = f-jet(f, 2)-corank_part(f);
     607  }
     608  poly g = cleardenom(f-jet(f, 2));
     609
     610  return(list(c, lambda, k, g));
    643611}
    644612example
     
    649617  poly f = (x2+3y-2z)^2+xyz-(x-y3+x2z3)^3;
    650618  realmorsesplit(f);
     619}
     620
     621///////////////////////////////////////////////////////////////////////////////
     622/*
     623   symmetric Gauss algorithm
     624
     625   If A is not a square matrix, then the largest upper or left submatrix
     626   is assumed to be symmetric.
     627*/
     628proc sym_reduce(matrix A)
     629{
     630  int r = nrows(A);
     631  int c = ncols(A);
     632  int n = r;
     633  if(n > c)
     634  {
     635    n = c;
     636  }
     637  poly q;
     638  int i, j;
     639  for(i = 1; i <= n; i++)
     640  {
     641    for(j = i+1; j <= n; j++)
     642    {
     643      if(A[i, j] != 0)
     644      {
     645        while(A[i, i] == 0)
     646        {
     647          A[1..r, i] = A[1..r, i]+A[1..r, j];
     648          A[i, 1..c] = A[i, 1..c]+A[j, 1..c];
     649        }
     650        q = A[i, j]/A[i, i];
     651        A[1..r, j] = A[1..r, j]-q*A[1..r, i];
     652        A[j, 1..c] = A[j, 1..c]-q*A[i, 1..c];
     653      }
     654    }
     655  }
     656  return(A);
    651657}
    652658
  • Singular/LIB/schubert.lib

    r93c5cf r906feb  
    1 //////////////////////////////////////////////////////////////////////////
     1////////////////////////////////////////////////////////////////////////////////
    22version="version schubert.lib 4.0.0.0 Jun_2013 "; // $Id$
    3 
    43category="Algebraic Geometry";
    54info="
    6 LIBRARY:    Schubert.lib   Proceduces for Intersection Theory
    7 
    8 AUTHOR:     Hiep Dang,  email: hiep@mathematik.uni-kl.de
     5LIBRARY:    Schubert.lib    Proceduces for Intersection Theory
     6
     7AUTHOR:     Hiep Dang,      email: hiep@mathematik.uni-kl.de
    98
    109OVERVIEW:
    1110
    12     We implement two new classes (variety and sheaf) and methods for computing
    13     with them. Here a variety is represented by the dimension and the Chow ring.
    14     A sheaf on a variety is represented by the Chern character.
    15 
     11    We implement new classes (variety, sheaf, stack, graph) and methods for
     12    computing with them. Here a variety is represented by a nonnegative integer
     13    which is its dimension and a graded ring which is its Chow ring. A sheaf is
     14    represented by a variety and a polynomial which is its Chern character.
    1615    In particular, we implement the concrete varieties such as projective spaces
    17     , Grassmannians, and projective bundles. Finally, the most important thing
    18     is a method for computing the intersection numbers (degrees of 0-cycles).
    19 
    20 PROCEDURES:
    21     makeVariety(int,ideal)            create a variety
    22     productVariety(variety,variety)   product of two varieties
    23     ChowRing(variety)                 create the Chow ring of a variety
    24     dimension(variety)                dimension of a variety
    25     relations(variety)                relations of a variety
    26     Grassmannian(int,int)             create a Grassmannian as a variety
    27     projectiveSpace(int)              create a projective space as a variety
    28     projectiveBundle(sheaf)           create a projective bundle as a variety
    29     integral(variety,poly)            degree of a 0-cycle on a variety
    30     makeSheaf(variety,poly)           create a sheaf
    31     ChernCharacter(sheaf)             the Chern character of a sheaf
    32     totalChernClass(sheaf)            the total Chern class of a sheaf
    33     ChernClass(sheaf,int)             the k-th Chern class of a sheaf
    34     topChernClass(sheaf)              the top Chern class of a sheaf
    35     totalSegreClass(sheaf)            the total Segre class of a sheaf
    36     dualSheaf(sheaf)                  the dual of a sheaf
    37     tensorSheaf(sheaf,sheaf)          the tensor of two sheaves
    38     symmetricPowerSheaf(sheaf,int)    the k-th symmetric power of a sheaf
    39     minusSheaf(sheaf,sheaf)           the quotient of two sheaves
    40     plusSheaf(sheaf,sheaf)            the direct sum of two sheaves
     16    , Grassmannians, and projective bundles.
     17
     18    An important task of this library is related to the computation of
     19    Gromov-Witten invariants. In particular, we implement new tools for the
     20    computation in equivariant intersection theory. These tools are based on the
     21    localization of moduli spaces of stable maps and Bott's formula. They are
     22    useful for the computation of Gromov-Witten invariants. In order to do this,
     23    we have to deal with moduli spaces of stable maps, which were introduced by
     24    Kontsevich, and the graphs corresponding to the fixed point components of a
     25    torus action on the moduli spaces of stable maps.
    4126
    4227REFERENCES:
     
    5237                intersection theory, 2010.
    5338
    54 KEYWORDS:        Intersection Theory, Enumerative Geometry, Schubert Calculus
     39    Maxim Kontsevich, Enumeration of rational curves via torus actions, 1995.
     40
     41PROCEDURES:
     42    mod_init()                          create new objects in this library
     43    makeVariety(int,ideal)              create a variety
     44    printVariety(variety)               print procedure for a variety
     45    productVariety(variety,variety)     make the product of two varieties
     46    ChowRing(variety)                   create the Chow ring of a variety
     47    Grassmannian(int,int)               create a Grassmannian as a variety
     48    projectiveSpace(int)                create a projective space as a variety
     49    projectiveBundle(sheaf)             create a projective bundle as a variety
     50    integral(variety,poly)              degree of a 0-cycle on a variety
     51    makeSheaf(variety,poly)             create a sheaf
     52    printSheaf(sheaf)                   print procedure for sheaves
     53    rankSheaf(sheaf)                    return the rank of a sheaf
     54    totalChernClass(sheaf)              compute the total Chern class of a sheaf
     55    ChernClass(sheaf,int)               compute the k-th Chern class of a sheaf
     56    topChernClass(sheaf)                compute the top Chern class of a sheaf
     57    totalSegreClass(sheaf)              compute the total Segre class of a sheaf
     58    dualSheaf(sheaf)                    make the dual of a sheaf
     59    tensorSheaf(sheaf,sheaf)            make the tensor of two sheaves
     60    symmetricPowerSheaf(sheaf,int)      make the k-th symmetric power of a sheaf
     61    quotSheaf(sheaf,sheaf)              make the quotient of two sheaves
     62    addSheaf(sheaf,sheaf)               make the direct sum of two sheaves
     63    makeGraph(list,list)                create a graph from a list of vertices
     64                                        and a list of edges
     65    printGraph(graph)                   print procedure for graphs
     66    moduliSpace(variety,int)            create a moduli space of stable maps as
     67                                        an algebraic stack
     68    printStack(stack)                   print procedure for stacks
     69    dimStack(stack)                     compute the dimension of a stack
     70    fixedPoints(stack)                  compute the list of graphs corresponding
     71                                        the fixed point components of a torus
     72                                        action on the stack
     73    contributionBundle(stack,graph)     compute the contribution bundle on a
     74                                        stack at a graph
     75    normalBundle(stack,graph)           compute the normal bundle on a stack at
     76                                        a graph
     77    multipleCover(int)                  compute the contribution of multiple
     78                                        covers of a smooth rational curve as a
     79                                        Gromov-Witten invariant
     80    linesHypersurface(int)              compute the number of lines on a general
     81                                        hypersurface
     82    rationalCurve(int,list)             compute the Gromov-Witten invariant
     83                                        corresponding the number of rational
     84                                        curves on a general Calabi-Yau threefold
     85    part(poly,int)                      compute a homogeneous component of a
     86                                        polynomial.
     87    parts(poly,int,int)                 compute the sum of homogeneous
     88                                        components of a polynomial
     89    logg(poly,int)                      compute Chern characters from total
     90                                        Chern classes.
     91    expp(poly,int)                      compute total Chern classes from Chern
     92                                        characters
     93    SchubertClass(list)                 compute the Schubert classes on a
     94                                        Grassmannian
     95    dualPartition(list)                 compute the dual of a partition
     96
     97KEYWORDS:       Intersection Theory; Enumerative Geometry; Schubert Calculus;
     98                Bott's formula.
     99
    55100";
    56101
     
    61106
    62107////////////////////////////////////////////////////////////////////////////////
    63 /// create new classes: varieties and sheaves //////////////////////////////////
     108/////////// create new objects in this library  ////////////////////////////////
    64109////////////////////////////////////////////////////////////////////////////////
    65110
    66111proc mod_init()
     112"USAGE:     mod_init();
     113THEORY:     This is to create new objects in this library such as variety,
     114            sheaf, stack, and graph.
     115KEYWORDS:   variety, sheaf, stack, graph
     116EXAMPLE:    example mod_init(); shows an example
     117"
    67118{
    68119    newstruct("variety","int dimension, ring baseRing, ideal relations");
    69120    newstruct("sheaf","variety currentVariety, poly ChernCharacter");
    70 
    71     system("install","variety","print",variety_print,1);
     121    newstruct("graph","list vertices, list edges");
     122    newstruct("stack","variety currentVariety, int degreeCurve");
     123
     124    system("install","variety","print",printVariety,1);
    72125    system("install","variety","*",productVariety,2);
    73     system("install","sheaf","print",sheaf_print,1);
     126    system("install","sheaf","print",printSheaf,1);
    74127    system("install","sheaf","*",tensorSheaf,2);
    75     system("install","sheaf","+",plusSheaf,2);
    76     system("install","sheaf","-",minusSheaf,2);
     128    system("install","sheaf","+",addSheaf,2);
     129    system("install","sheaf","-",quotSheaf,2);
     130    system("install","sheaf","^",symmetricPowerSheaf,2);
     131    system("install","graph","print",printGraph,1);
     132    system("install","stack","print",printStack,1);
     133}
     134example
     135{
     136    "EXAMPLE:"; echo=2;
     137    mod_init();
     138}
     139
     140////////////////////////////////////////////////////////////////////////////////
     141//////// Procedures concerned with moduli spaces of stable maps ////////////////
     142////////////////////////////////////////////////////////////////////////////////
     143
     144proc printStack(stack M)
     145"USAGE:     printStack(M); M stack
     146ASSUME:     M is a moduli space of stable maps.
     147THEORY:     This is the print function used by Singular to print a stack.
     148KEYWORDS:   stack, moduli space of stable maps
     149EXAMPLE:    example printStack; shows an example
     150"
     151{
     152    "A moduli space of dimension", dimStack(M);
     153}
     154example
     155{
     156    "EXAMPLE:"; echo=2;
     157    ring r = 0,(x),dp;
     158    variety P = projectiveSpace(4);
     159    stack M = moduliSpace(P,2);
     160    M;
     161}
     162
     163proc moduliSpace(variety V, int d)
     164"USAGE:     moduliSpace(V,d); V variety, d int
     165ASSUME:     V is a projective space and d is a positive integer.
     166THEORY:     This is the function used by Singular to create a moduli space of
     167            stable maps from a genus zero curve to a projective space.
     168KEYWORDS:   stack, moduli space of stable maps, rational curves
     169EXAMPLE:    example moduliSpace; shows an example
     170"
     171{
     172    stack M;
     173    M.currentVariety = V;
     174    M.degreeCurve = d;
     175    return(M);
     176}
     177example
     178{
     179    "EXAMPLE:"; echo=2;
     180    ring r = 0,(x),dp;
     181    variety P = projectiveSpace(4);
     182    stack M = moduliSpace(P,2);
     183    M;
     184}
     185
     186proc dimStack(stack M)
     187"USAGE:     dimStack(M); M stack
     188RETURN:     int
     189INPUT:      M is a moduli space of stable maps.
     190OUTPUT:     the dimension of moduli space of stable maps.
     191KEYWORDS:   dimension, moduli space of stable maps, rational curves
     192EXAMPLE:    example dimStack; shows an example
     193"
     194{
     195    variety V = M.currentVariety;
     196    int n = V.dimension;
     197    int d = M.degreeCurve;
     198    return (n*d+n+d-3);
     199}
     200example
     201{
     202    "EXAMPLE:"; echo=2;
     203    ring r = 0,(x),dp;
     204    variety P = projectiveSpace(4);
     205    stack M = moduliSpace(P,2);
     206    dimStack(M);
     207}
     208
     209proc fixedPoints(stack M)
     210"USAGE:     fixedPoints(M); M stack
     211RETURN:     list
     212INPUT:      M is a moduli space of stable maps.
     213OUTPUT:     a list of graphs corresponding the fixed point components of a torus
     214            action on a moduli space of stable maps.
     215KEYWORDS:   fixed points, moduli space of stable maps, graph
     216EXAMPLE:    example fixedPoints; shows an example
     217"
     218{
     219    int i,j,k,h,m,n,p;
     220    list l;
     221    int d = M.degreeCurve;
     222    variety V = M.currentVariety;
     223    int r = V.dimension;
     224    for (i=0;i<=r;i++)
     225    {
     226        for (j=0;j<=r;j++)
     227        {
     228            if (i <> j)
     229            {
     230                l = insert(l,list(graph1(d,i,j),2*d),size(l));
     231            }
     232        }
     233    }
     234    if (d == 2)
     235    {
     236        for (i=0;i<=r;i++)
     237        {
     238            for (j=0;j<=r;j++)
     239            {
     240                for (k=0;k<=r;k++)
     241                {
     242                    if (i <> j and j <> k)
     243                    {
     244                        l = insert(l,list(graph2(list(1,1),i,j,k),2),size(l));
     245                    }
     246                }
     247            }
     248        }
     249    }
     250    if (d == 3)
     251    {
     252        for (i=0;i<=r;i++)
     253        {
     254            for (j=0;j<=r;j++)
     255            {
     256                for (k=0;k<=r;k++)
     257                {
     258                    if (i <> j and j <> k)
     259                    {
     260                        l = insert(l,list(graph2(list(2,1),i,j,k),2),size(l));
     261                        for (h=0;h<=r;h++)
     262                        {
     263                            if (h <> k)
     264                            {
     265                                l = insert(l,list(graph31(list(1,1,1),i,j,k,h),2),size(l));
     266                            }
     267                            if (h <> j)
     268                            {
     269                                l = insert(l,list(graph32(list(1,1,1),i,j,k,h),6),size(l));
     270                            }
     271                        }
     272                    }
     273                }
     274            }
     275        }
     276    }
     277    if (d == 4)
     278    {
     279        for (i=0;i<=r;i++)
     280        {
     281            for (j=0;j<=r;j++)
     282            {
     283                for (k=0;k<=r;k++)
     284                {
     285                    if (i <> j and j <> k)
     286                    {
     287                        l = insert(l,list(graph2(list(3,1),i,j,k),3),size(l));
     288                        l = insert(l,list(graph2(list(2,2),i,j,k),8),size(l));
     289                        for (h=0;h<=r;h++)
     290                        {
     291                            if (h <> k)
     292                            {
     293                                l = insert(l,list(graph31(list(2,1,1),i,j,k,h),2),size(l));
     294                                l = insert(l,list(graph31(list(1,2,1),i,j,k,h),4),size(l));
     295                            }
     296                            if (h <> j)
     297                            {
     298                                l = insert(l,list(graph32(list(2,1,1),i,j,k,h),4),size(l));
     299                            }
     300                            for (m=0;m<=r;m++)
     301                            {
     302                                if (k <> h and m <> h)
     303                                {
     304                                    l = insert(l,list(graph41(list(1,1,1,1),i,j,k,h,m),2),size(l));
     305                                }
     306                                if (k <> h and m <> k)
     307                                {
     308                                    l = insert(l,list(graph42(list(1,1,1,1),i,j,k,h,m),2),size(l));
     309                                }
     310                                if (h <> j and m <> j)
     311                                {
     312                                    l = insert(l,list(graph43(list(1,1,1,1),i,j,k,h,m),24),size(l));
     313                                }
     314                            }
     315                        }
     316                    }
     317                }
     318            }
     319        }
     320    }
     321    if (d == 5)
     322    {
     323        for (i=0;i<=r;i++)
     324        {
     325            for (j=0;j<=r;j++)
     326            {
     327                for (k=0;k<=r;k++)
     328                {
     329                    if (i <> j and j <> k)
     330                    {
     331                        l = insert(l,list(graph2(list(4,1),i,j,k),4),size(l));
     332                        l = insert(l,list(graph2(list(3,2),i,j,k),6),size(l));
     333                        for (h=0;h<=r;h++)
     334                        {
     335                            if (k <> h)
     336                            {
     337                                l = insert(l,list(graph31(list(3,1,1),i,j,k,h),3),size(l));
     338                                l = insert(l,list(graph31(list(1,3,1),i,j,k,h),6),size(l));
     339                                l = insert(l,list(graph31(list(2,2,1),i,j,k,h),4),size(l));
     340                                l = insert(l,list(graph31(list(2,1,2),i,j,k,h),8),size(l));
     341                            }
     342                            if (j <> h)
     343                            {
     344                                l = insert(l,list(graph32(list(3,1,1),i,j,k,h),6),size(l));
     345                                l = insert(l,list(graph32(list(2,2,1),i,j,k,h),8),size(l));
     346                            }
     347                            for (m=0;m<=r;m++)
     348                            {
     349                                if (k <> h and h <> m)
     350                                {
     351                                    l = insert(l,list(graph41(list(2,1,1,1),i,j,k,h,m),2),size(l));
     352                                    l = insert(l,list(graph41(list(1,2,1,1),i,j,k,h,m),2),size(l));
     353                                }
     354                                if (k <> h and k <> m)
     355                                {
     356                                    l = insert(l,list(graph42(list(2,1,1,1),i,j,k,h,m),4),size(l));
     357                                    l = insert(l,list(graph42(list(1,2,1,1),i,j,k,h,m),4),size(l));
     358                                    l = insert(l,list(graph42(list(1,1,2,1),i,j,k,h,m),2),size(l));
     359                                }
     360                                if (j <> h and j <> m)
     361                                {
     362                                    l = insert(l,list(graph43(list(2,1,1,1),i,j,k,h,m),12),size(l));
     363                                }
     364                                for (n=0;n<=r;n++)
     365                                {
     366                                    if (k <> h and h <> m and m <> n)
     367                                    {
     368                                        l = insert(l,list(graph51(list(1,1,1,1,1),i,j,k,h,m,n),2),size(l));
     369                                    }
     370                                    if (k <> h and h <> m and h <> n)
     371                                    {
     372                                        l = insert(l,list(graph52(list(1,1,1,1,1),i,j,k,h,m,n),2),size(l));
     373                                    }
     374                                    if (k <> h and k <> m and k <> n)
     375                                    {
     376                                        l = insert(l,list(graph53(list(1,1,1,1,1),i,j,k,h,m,n),6),size(l));
     377                                    }
     378                                    if (j <> h and h <> m and h <> n)
     379                                    {
     380                                        l = insert(l,list(graph54(list(1,1,1,1,1),i,j,k,h,m,n),8),size(l));
     381                                    }
     382                                    if (k <> h and k <> m and h <> n)
     383                                    {
     384                                        l = insert(l,list(graph55(list(1,1,1,1,1),i,j,k,h,m,n),2),size(l));
     385                                    }
     386                                    if (j <> h and j <> m and j <> n)
     387                                    {
     388                                        l = insert(l,list(graph56(list(1,1,1,1,1),i,j,k,h,m,n),120),size(l));
     389                                    }
     390                                }
     391                            }
     392                        }
     393                    }
     394                }
     395            }
     396        }
     397    }
     398    if (d == 6)
     399    {
     400        for (i=0;i<=r;i++)
     401        {
     402            for (j=0;j<=r;j++)
     403            {
     404                for (k=0;k<=r;k++)
     405                {
     406                    if (i <> j and j <> k)
     407                    {
     408                        l = insert(l,list(graph2(list(5,1),i,j,k),5),size(l));
     409                        l = insert(l,list(graph2(list(4,2),i,j,k),8),size(l));
     410                        l = insert(l,list(graph2(list(3,3),i,j,k),18),size(l));
     411                        for (h=0;h<=r;h++)
     412                        {
     413                            if (k <> h)
     414                            {
     415                                l = insert(l,list(graph31(list(4,1,1),i,j,k,h),4),size(l));
     416                                l = insert(l,list(graph31(list(1,4,1),i,j,k,h),8),size(l));
     417                                l = insert(l,list(graph31(list(3,2,1),i,j,k,h),6),size(l));
     418                                l = insert(l,list(graph31(list(3,1,2),i,j,k,h),6),size(l));
     419                                l = insert(l,list(graph31(list(1,3,2),i,j,k,h),6),size(l));
     420                                l = insert(l,list(graph31(list(2,2,2),i,j,k,h),16),size(l));
     421                            }
     422                            if (j <> h)
     423                            {
     424                                l = insert(l,list(graph32(list(4,1,1),i,j,k,h),8),size(l));
     425                                l = insert(l,list(graph32(list(3,2,1),i,j,k,h),6),size(l));
     426                                l = insert(l,list(graph32(list(2,2,2),i,j,k,h),48),size(l));
     427                            }
     428                            for (m=0;m<=r;m++)
     429                            {
     430                                if (k <> h and h <> m)
     431                                {
     432                                    l = insert(l,list(graph41(list(3,1,1,1),i,j,k,h,m),3),size(l));
     433                                    l = insert(l,list(graph41(list(1,3,1,1),i,j,k,h,m),3),size(l));
     434                                    l = insert(l,list(graph41(list(2,2,1,1),i,j,k,h,m),4),size(l));
     435                                    l = insert(l,list(graph41(list(2,1,2,1),i,j,k,h,m),4),size(l));
     436                                    l = insert(l,list(graph41(list(2,1,1,2),i,j,k,h,m),8),size(l));
     437                                    l = insert(l,list(graph41(list(1,2,2,1),i,j,k,h,m),8),size(l));
     438                                }
     439                                if (k <> h and k <> m)
     440                                {
     441                                    l = insert(l,list(graph42(list(3,1,1,1),i,j,k,h,m),6),size(l));
     442                                    l = insert(l,list(graph42(list(1,3,1,1),i,j,k,h,m),6),size(l));
     443                                    l = insert(l,list(graph42(list(1,1,3,1),i,j,k,h,m),3),size(l));
     444                                    l = insert(l,list(graph42(list(2,2,1,1),i,j,k,h,m),8),size(l));
     445                                    l = insert(l,list(graph42(list(1,1,2,2),i,j,k,h,m),8),size(l));
     446                                    l = insert(l,list(graph42(list(2,1,2,1),i,j,k,h,m),4),size(l));
     447                                    l = insert(l,list(graph42(list(1,2,2,1),i,j,k,h,m),4),size(l));
     448                                }
     449                                if (j <> h and j <> m)
     450                                {
     451                                    l = insert(l,list(graph43(list(3,1,1,1),i,j,k,h,m),18),size(l));
     452                                    l = insert(l,list(graph43(list(2,2,1,1),i,j,k,h,m),16),size(l));
     453                                }
     454                                for (n=0;n<=r;n++)
     455                                {
     456                                    if (k <> h and h <> m and m <> n)
     457                                    {
     458                                        l = insert(l,list(graph51(list(2,1,1,1,1),i,j,k,h,m,n),2),size(l));
     459                                        l = insert(l,list(graph51(list(1,2,1,1,1),i,j,k,h,m,n),2),size(l));
     460                                        l = insert(l,list(graph51(list(1,1,2,1,1),i,j,k,h,m,n),4),size(l));
     461                                    }
     462                                    if (k <> h and h <> m and h <> n)
     463                                    {
     464                                        l = insert(l,list(graph52(list(2,1,1,1,1),i,j,k,h,m,n),4),size(l));
     465                                        l = insert(l,list(graph52(list(1,2,1,1,1),i,j,k,h,m,n),4),size(l));
     466                                        l = insert(l,list(graph52(list(1,1,2,1,1),i,j,k,h,m,n),4),size(l));
     467                                        l = insert(l,list(graph52(list(1,1,1,2,1),i,j,k,h,m,n),2),size(l));
     468                                    }
     469                                    if (k <> h and k <> m and k <> n)
     470                                    {
     471                                        l = insert(l,list(graph53(list(2,1,1,1,1),i,j,k,h,m,n),12),size(l));
     472                                        l = insert(l,list(graph53(list(1,2,1,1,1),i,j,k,h,m,n),12),size(l));
     473                                        l = insert(l,list(graph53(list(1,1,2,1,1),i,j,k,h,m,n),4),size(l));
     474                                    }
     475                                    if (j <> h and h <> m and h <> n)
     476                                    {
     477                                        l = insert(l,list(graph54(list(2,1,1,1,1),i,j,k,h,m,n),4),size(l));
     478                                        l = insert(l,list(graph54(list(1,1,2,1,1),i,j,k,h,m,n),16),size(l));
     479                                    }
     480                                    if (k <> h and k <> m and h <> n)
     481                                    {
     482                                        l = insert(l,list(graph55(list(2,1,1,1,1),i,j,k,h,m,n),2),size(l));
     483                                        l = insert(l,list(graph55(list(1,2,1,1,1),i,j,k,h,m,n),2),size(l));
     484                                        l = insert(l,list(graph55(list(1,1,1,2,1),i,j,k,h,m,n),4),size(l));
     485                                    }
     486                                    if (j <> h and j <> m and j <> n)
     487                                    {
     488                                        l = insert(l,list(graph56(list(2,1,1,1,1),i,j,k,h,m,n),48),size(l));
     489                                    }
     490                                    for (p=0;p<=r;p++)
     491                                    {
     492                                        if (k <> h and h <> m and m <> n and n <> p)
     493                                        {
     494                                            l = insert(l,list(graph61(list(1,1,1,1,1,1),i,j,k,h,m,n,p),2),size(l));
     495                                        }
     496                                        if (k <> h and h <> m and m <> n and m <> p)
     497                                        {
     498                                            l = insert(l,list(graph62(list(1,1,1,1,1,1),i,j,k,h,m,n,p),2),size(l));
     499                                        }
     500                                        if (k <> h and h <> m and h <> n and n <> p)
     501                                        {
     502                                            l = insert(l,list(graph63(list(1,1,1,1,1,1),i,j,k,h,m,n,p),1),size(l));
     503                                        }
     504                                        if (k <> h and h <> m and h <> n and h <> p)
     505                                        {
     506                                            l = insert(l,list(graph64(list(1,1,1,1,1,1),i,j,k,h,m,n,p),6),size(l));
     507                                        }
     508                                        if (k <> h and k <> m and k <> n and n <> p)
     509                                        {
     510                                            l = insert(l,list(graph65(list(1,1,1,1,1,1),i,j,k,h,m,n,p),4),size(l));
     511                                        }
     512                                        if (k <> h and k <> m and m <> p and h <> n)
     513                                        {
     514                                            l = insert(l,list(graph66(list(1,1,1,1,1,1),i,j,k,h,m,n,p),6),size(l));
     515                                        }
     516                                        if (j <> h and h <> m and m <> n and m <> p)
     517                                        {
     518                                            l = insert(l,list(graph67(list(1,1,1,1,1,1),i,j,k,h,m,n,p),8),size(l));
     519                                        }
     520                                        if (j <> h and h <> m and h <> n and h <> p)
     521                                        {
     522                                            l = insert(l,list(graph68(list(1,1,1,1,1,1),i,j,k,h,m,n,p),12),size(l));
     523                                        }
     524                                        if (j <> h and h <> m and h <> n and n <> p)
     525                                        {
     526                                            l = insert(l,list(graph69(list(1,1,1,1,1,1),i,j,k,h,m,n,p),2),size(l));
     527                                        }
     528                                        if (k <> h and k <> m and k <> n and k <> p)
     529                                        {
     530                                            l = insert(l,list(graph610(list(1,1,1,1,1,1),i,j,k,h,m,n,p),24),size(l));
     531                                        }
     532                                        if (j <> h and j <> m and j <> n and j <> p)
     533                                        {
     534                                            l = insert(l,list(graph611(list(1,1,1,1,1,1),i,j,k,h,m,n,p),720),size(l));
     535                                        }
     536                                    }
     537                                }
     538                            }
     539                        }
     540                    }
     541                }
     542            }
     543        }
     544    }
     545    return (l);
     546}
     547example
     548{
     549    "EXAMPLE:"; echo=2;
     550    ring r = 0,(x),dp;
     551    variety P = projectiveSpace(4);
     552    stack M = moduliSpace(P,2);
     553    def F = fixedPoints(M);
     554    size(F);
     555    typeof(F[1]) == "list";
     556    typeof(F[1][1]) == "graph";
     557    typeof(F[1][2]) == "int";
     558}
     559
     560static proc torusList(variety P)
     561"USAGE:     torusList(P); P variety
     562RETURN:     list
     563INPUT:      P is a projective space
     564OUTPUT:     a list of numbers
     565THEORY:     This is a procedure concerning the enumeration of rational curves.
     566KEYWORDS:   torus action
     567EXAMPLE:    example torusList; shows an example
     568"
     569{
     570    int i;
     571    int n = P.dimension;
     572    list l;
     573    for (i=0;i<=n;i++)
     574    {
     575        l = insert(l,number(5^i),size(l));
     576    }
     577    return (l);
     578}
     579example
     580{
     581    "EXAMPLE:"; echo=2;
     582    ring r = 0,(x),dp;
     583    variety P = projectiveSpace(4);
     584    def L = torusList(P);
     585    L;
     586}
     587
     588proc contributionBundle(stack M, graph G, list #)
     589"USAGE:     contributionBundle(M,G,#); M stack, G graph, # list
     590RETURN:     number
     591INPUT:      M is a moduli space of stable maps, G is a graph, # is a list.
     592OUTPUT:     a number corresponding to the contribution bundle on a moduli space
     593            of stable maps at a fixed point component (graph)
     594KEYWORDS:   contribution bundle, graph, multiple cover, rational curve,
     595SEE ALSO:   normalBundle
     596EXAMPLE:    example contributionBundle; shows an example
     597"
     598{
     599    def R = basering;
     600    setring R;
     601    int i,j,a;
     602    variety P = M.currentVariety;
     603    def L = torusList(P);
     604    int r = P.dimension;
     605    int d;
     606    if (size(#)==0) {d = 2*r - 3;}
     607    else
     608    {
     609        if (typeof(#[1]) == "int") {d = #[1];}
     610        else {Error("invalid optional argument");}
     611    }
     612    list e = G.edges;
     613    list v = G.vertices;
     614    number E = 1;
     615    number V = 1;
     616    if (r == 1)
     617    {
     618        for (i=1;i<=size(v);i++)
     619        {
     620            V = V*(-L[v[i][1]+1])^(v[i][2]-1);
     621        }
     622        for (j=1;j<=size(e);j++)
     623        {
     624            number f = 1;
     625            if (e[j][3]<>1)
     626            {
     627                for (a=1;a<e[j][3];a++)
     628                {
     629                    f=f*(-a*L[e[j][1]+1]-(e[j][3]-a)*L[e[j][2]+1])/e[j][3];
     630                }
     631            }
     632            E = E*f;
     633            kill f;
     634        }
     635        return ((E*V)^2);
     636    }
     637    else
     638    {
     639        for (i=1;i<=size(v);i++)
     640        {
     641            V = V*((d*L[v[i][1]+1])^(v[i][2]-1));
     642        }
     643        for (j=1;j<=size(e);j++)
     644        {
     645            number f = 1;
     646            for (a=0;a<=d*e[j][3];a++)
     647            {
     648                f = f*((a*L[e[j][1]+1]+(d*e[j][3]-a)*L[e[j][2]+1])/e[j][3]);
     649            }
     650            E = E*f;
     651            kill f;
     652        }
     653        return (E/V);
     654    }
     655}
     656example
     657{
     658    "EXAMPLE:"; echo=2;
     659    ring r = 0,(x),dp;
     660    variety P = projectiveSpace(4);
     661    stack M = moduliSpace(P,2);
     662    def F = fixedPoints(M);
     663    graph G = F[1][1];
     664    number f = contributionBundle(M,G);
     665    number g = contributionBundle(M,G,5);
     666    f == g;
     667}
     668
     669proc normalBundle(stack M, graph G)
     670"USAGE:     normalBundle(M,G); M stack, G graph
     671RETURN:     number
     672INPUT:      M is a moduli space of stable maps, G is a graph
     673OUTPUT:     a number corresponding to the normal bundle on a moduli space of
     674            stable maps at a graph
     675KEYWORDS:   normal bundle, graph, rational curves, mutiple covers, lines on
     676            hypersurfaces
     677SEE ALSO:   contributionBundle
     678EXAMPLE:    example normalBundle; shows an example
     679{
     680    def R = basering;
     681    setring R;
     682    variety P = M.currentVariety;
     683    def L = torusList(P);
     684    int n = P.dimension;
     685    list e = G.edges;
     686    list v = G.vertices;
     687    int i,j,k,h,b,m,a;
     688    number N = 1;
     689    for (j=1;j<=size(e);j++)
     690    {
     691        int d = e[j][3];
     692        number c = (-1)^d*factorial(d)^2;
     693        number y = c*(L[e[j][1]+1]-L[e[j][2]+1])^(2*d)/(d^(2*d));
     694        for (k=0;k<=n;k++)
     695        {
     696            if (k <> e[j][1] and k <> e[j][2])
     697            {
     698                for (a=0;a<=d;a++)
     699                {
     700                    y=y*((a*L[e[j][1]+1]+(d-a)*L[e[j][2]+1])/d - L[k+1]);
     701                }
     702            }
     703        }
     704        N = N*y;
     705        kill y,d,c;
     706    }
     707    for (i=1;i<=size(v);i++)
     708    {
     709        number F = 1;
     710        for (h=3;h<=size(v[i]);h++)
     711        {
     712            F = F*(L[v[i][h][1]+1]-L[v[i][h][2]+1])/v[i][h][3];
     713        }
     714        if (v[i][2] == 1)
     715        {
     716            N = N/F;
     717            kill F;
     718        }
     719        else
     720        {
     721            number z = 1;
     722            for (m=0;m<=n;m++)
     723            {
     724                if (m<>v[i][1])
     725                {
     726                    z = z*(L[v[i][1]+1]-L[m+1]);
     727                }
     728            }
     729            if (v[i][2] == 3)
     730            {
     731                N = N*F/z^2;
     732                kill F,z;
     733            }
     734            else
     735            {
     736                number g = 0;
     737                for (b=3;b<=size(v[i]);b++)
     738                {
     739                    g = g + v[i][b][3]/(L[v[i][b][1]+1]-L[v[i][b][2]+1]);
     740                }
     741                N = N*F*g^(3-v[i][2])/(z^(v[i][2]-1));
     742                kill g,F,z;
     743            }
     744        }
     745    }
     746    return (N);
     747}
     748example
     749{
     750    "EXAMPLE:"; echo=2;
     751    ring r = 0,(x),dp;
     752    variety P = projectiveSpace(4);
     753    stack M = moduliSpace(P,2);
     754    def F = fixedPoints(M);
     755    graph G = F[1][1];
     756    number f = normalBundle(M,G);
     757    f <> 0;
     758}
     759
     760proc multipleCover(int d)
     761"USAGE:     multipleCover(d); d int
     762RETURN:     number
     763THEORY:     This is the contribution of degree d multiple covers of a smooth
     764            rational curve as a Gromov-Witten invariant.
     765KEYWORDS:   Gromov-Witten invariants, multiple covers
     766SEE ALSO:   rationalCurve, linesHypersurface
     767EXAMPLE:    example multipleCover; shows an example
     768"
     769{
     770    def R = basering;
     771    setring R;
     772    variety P = projectiveSpace(1);
     773    stack M = moduliSpace(P,d);
     774    def F = fixedPoints(M);
     775    int i;
     776    number r = 0;
     777    for (i=1;i<=size(F);i++)
     778    {
     779        graph G = F[i][1];
     780        number s = contributionBundle(M,G);
     781        number t = F[i][2]*normalBundle(M,G);
     782        r = r + s/t;
     783        kill s,t,G;
     784    }
     785    return (r);
     786}
     787example
     788{
     789    "EXAMPLE:"; echo=2;
     790    ring r = 0,(x),dp;
     791    multipleCover(1);
     792    multipleCover(2);
     793    multipleCover(3);
     794    multipleCover(4);
     795    multipleCover(5);
     796}
     797
     798proc linesHypersurface(int n)
     799"USAGE:     linesHypersurface(n); n int
     800RETURN:     number
     801THEORY:     This is the number of lines on a general hypersurface of degree
     802            d = 2n-3 in an n-dimensional projective space.
     803KEYWORDS:   Gromov-Witten invariants, lines on hypersurfaces
     804SEE ALSO:   linesHypersurface, multipleCover
     805EXAMPLE:    example linesHypersurface; shows an example
     806"
     807{
     808    def R = basering;
     809    setring R;
     810    variety P = projectiveSpace(n);
     811    stack M = moduliSpace(P,1);
     812    def F = fixedPoints(M);
     813    int i;
     814    poly r = 0;
     815    for (i=1;i<=size(F);i++)
     816    {
     817        graph G = F[i][1];
     818        number s = contributionBundle(M,G);
     819        number t = F[i][2]*normalBundle(M,G);
     820        r = r + s/t;
     821        kill s,t,G;
     822    }
     823    return (r);
     824}
     825example
     826{
     827    "EXAMPLE:"; echo=2;
     828    ring r = 0,(x),dp;
     829    linesHypersurface(2);
     830    linesHypersurface(3);
     831    linesHypersurface(4);
     832    linesHypersurface(5);
     833    linesHypersurface(6);
     834    linesHypersurface(7);
     835    linesHypersurface(8);
     836    linesHypersurface(9);
     837    linesHypersurface(10);
     838}
     839
     840proc rationalCurve(int d, list #)
     841"USAGE:     rationalCurve(d,#); d int, # list
     842RETURN:     number
     843THEORY:     This is the Gromov-Witten invariant corresponding the number of
     844            rational curves on a general Calabi-Yau threefold.
     845KEYWORDS:   Gromov-Witten invariants, rational curves on Calabi-Yau threefolds
     846SEE ALSO:   linesHypersurface, multipleCover
     847EXAMPLE:    example rationalCurve; shows an example
     848"
     849{
     850    def R = basering;
     851    setring R;
     852    int n,i,j;
     853    if (size(#) == 0) {n = 4; list l = 5;}
     854    else {n = size(#)+3; list l = #;}
     855    variety P = projectiveSpace(n);
     856    stack M = moduliSpace(P,d);
     857    def F = fixedPoints(M);
     858    number r = 0;
     859    for (i=1;i<=size(F);i++)
     860    {
     861        graph G = F[i][1];
     862        number s = 1;
     863        for (j=1;j<=size(l);j++)
     864        {
     865            s = s*contributionBundle(M,G,list(l[j]));
     866        }
     867        number t = F[i][2]*normalBundle(M,G);
     868        r = r + s/t;
     869        kill s,t,G;
     870    }
     871    return (r);
     872}
     873example
     874{
     875    "EXAMPLE:"; echo=2;
     876    ring r = 0,(x),dp;
     877    rationalCurve(1);
     878    /*
     879    rationalCurve(2);
     880    rationalCurve(3);
     881    rationalCurve(4);
     882    rationalCurve(5);
     883    rationalCurve(1,list(4,2));
     884    rationalCurve(1,list(3,3));
     885    rationalCurve(1,list(3,2,2));
     886    rationalCurve(1,list(2,2,2,2));
     887    rationalCurve(2,list(4,2));
     888    rationalCurve(2,list(3,3));
     889    rationalCurve(2,list(3,2,2));
     890    rationalCurve(2,list(2,2,2,2));
     891    rationalCurve(3,list(4,2));
     892    rationalCurve(3,list(3,3));
     893    rationalCurve(3,list(3,2,2));
     894    rationalCurve(3,list(2,2,2,2));
     895    rationalCurve(4,list(4,2));
     896    rationalCurve(4,list(3,3));
     897    rationalCurve(4,list(3,2,2));
     898    rationalCurve(4,list(2,2,2,2));
     899    rationalCurve(5,list(4,2));
     900    rationalCurve(5,list(3,3));
     901    rationalCurve(5,list(3,2,2));
     902    rationalCurve(5,list(2,2,2,2));
     903    */
     904}
     905
     906////////////////////////////////////////////////////////////////////////////////
     907/////////// Procedures concerned with graphs ///////////////////////////////////
     908////////////////////////////////////////////////////////////////////////////////
     909
     910proc printGraph(graph G)
     911"USAGE:     printGraph(G); G graph
     912ASSUME:     G is a graph.
     913THEORY:     This is the print function used by Singular to print a graph.
     914KEYWORDS:   graph
     915EXAMPLE:    example printGraph; shows an example
     916"
     917{
     918    "A graph with", size(G.vertices), "vertices and", size(G.edges), "edges";
     919}
     920example
     921{
     922    "EXAMPLE:"; echo=2;
     923    ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
     924    graph G = makeGraph(list(list(0,1,list(0,1,2)),list(1,1,list(1,0,2))),
     925    list(list(0,1,2)));
     926    G;
     927}
     928
     929proc makeGraph(list v, list e)
     930"USAGE:     makeGraph(v,e); v list, e list
     931ASSUME:     v is a list of vertices, e is a list of edges.
     932RETURN:     graph with vertices v and edges e.
     933THEORY:     Creates a graph from a list of vertices and edges.
     934KEYWORDS:   graph
     935EXAMPLE:    example makeGraph; shows an example
     936{
     937    graph G;
     938    G.vertices = v;
     939    G.edges = e;
     940    return(G);
     941}
     942example
     943{
     944    "EXAMPLE:"; echo=2;
     945    ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
     946    graph G = makeGraph(list(list(0,1,list(0,1,2)),list(1,1,list(1,0,2))),
     947    list(list(0,1,2)));
     948    G;
     949}
     950
     951static proc graph1(int d, int i, int j)
     952{
     953    graph G;
     954    list f1 = i,j,d;
     955    list f2 = j,i,d;
     956    list v1 = i,1,f1;
     957    list v2 = j,1,f2;
     958    G.vertices = v1,v2;
     959    G.edges = list(f1);
     960    return (G);
     961}
     962
     963static proc graph2(list d, int i, int j, int k)
     964{
     965    graph G;
     966    list f1 = i,j,d[1];
     967    list f2 = j,i,d[1];
     968    list f3 = j,k,d[2];
     969    list f4 = k,j,d[2];
     970    list v1 = i,1,f1;
     971    list v2 = j,2,f2,f3;
     972    list v3 = k,1,f4;
     973    G.vertices = v1,v2,v3;
     974    G.edges = f1,f3;
     975    return (G);
     976}
     977
     978static proc graph31(list d, int i, int j, int k, int h)
     979{
     980    graph G;
     981    list f1 = i,j,d[1];
     982    list f2 = j,i,d[1];
     983    list f3 = j,k,d[2];
     984    list f4 = k,j,d[2];
     985    list f5 = k,h,d[3];
     986    list f6 = h,k,d[3];
     987    list v1 = i,1,f1;
     988    list v2 = j,2,f2,f3;
     989    list v3 = k,2,f4,f5;
     990    list v4 = h,1,f6;
     991    G.vertices = v1,v2,v3,v4;
     992    G.edges = f1,f3,f5;
     993    return (G);
     994}
     995
     996static proc graph32(list d, int i, int j, int k, int h)
     997{
     998    graph G;
     999    list f1 = i,j,d[1];
     1000    list f2 = j,i,d[1];
     1001    list f3 = j,k,d[2];
     1002    list f4 = j,h,d[3];
     1003    list f5 = k,j,d[2];
     1004    list f6 = h,j,d[3];
     1005    list v1 = i,1,f1;
     1006    list v2 = j,3,f2,f3,f4;
     1007    list v3 = k,1,f5;
     1008    list v4 = h,1,f6;
     1009    G.vertices = v1,v2,v3,v4;
     1010    G.edges = f1,f3,f4;
     1011    return (G);
     1012}
     1013
     1014static proc graph41(list d, int i, int j, int k, int h, int l)
     1015{
     1016    graph G;
     1017    list f1 = i,j,d[1];
     1018    list f2 = j,i,d[1];
     1019    list f3 = j,k,d[2];
     1020    list f4 = k,j,d[2];
     1021    list f5 = k,h,d[3];
     1022    list f6 = h,k,d[3];
     1023    list f7 = h,l,d[4];
     1024    list f8 = l,h,d[4];
     1025    list v1 = i,1,f1;
     1026    list v2 = j,2,f2,f3;
     1027    list v3 = k,2,f4,f5;
     1028    list v4 = h,2,f6,f7;
     1029    list v5 = l,1,f8;
     1030    G.vertices = v1,v2,v3,v4,v5;
     1031    G.edges = f1,f3,f5,f7;
     1032    return (G);
     1033}
     1034
     1035static proc graph42(list d, int i, int j, int k, int h, int l)
     1036{
     1037    graph G;
     1038    list f1 = i,j,d[1];
     1039    list f2 = j,i,d[1];
     1040    list f3 = j,k,d[2];
     1041    list f4 = k,j,d[2];
     1042    list f5 = k,h,d[3];
     1043    list f6 = k,l,d[4];
     1044    list f7 = h,k,d[3];
     1045    list f8 = l,k,d[4];
     1046    list v1 = i,1,f1;
     1047    list v2 = j,2,f2,f3;
     1048    list v3 = k,3,f4,f5,f6;
     1049    list v4 = h,1,f7;
     1050    list v5 = l,1,f8;
     1051    G.vertices = v1,v2,v3,v4,v5;
     1052    G.edges = f1,f3,f5,f6;
     1053    return (G);
     1054}
     1055
     1056static proc graph43(list d, int i, int j, int k, int h, int l)
     1057{
     1058    graph G;
     1059    list f1 = i,j,d[1];
     1060    list f2 = j,i,d[1];
     1061    list f3 = j,k,d[2];
     1062    list f4 = j,h,d[3];
     1063    list f5 = j,l,d[4];
     1064    list f6 = k,j,d[2];
     1065    list f7 = h,j,d[3];
     1066    list f8 = l,j,d[4];
     1067    list v1 = i,1,f1;
     1068    list v2 = j,4,f2,f3,f4,f5;
     1069    list v3 = k,1,f6;
     1070    list v4 = h,1,f7;
     1071    list v5 = l,1,f8;
     1072    G.vertices = v1,v2,v3,v4,v5;
     1073    G.edges = f1,f3,f4,f5;
     1074    return (G);
     1075}
     1076
     1077static proc graph51(list d, int i, int j, int k, int h, int m, int n)
     1078{
     1079    graph G;
     1080    list f1 = i,j,d[1];
     1081    list f2 = j,i,d[1];
     1082    list f3 = j,k,d[2];
     1083    list f4 = k,j,d[2];
     1084    list f5 = k,h,d[3];
     1085    list f6 = h,k,d[3];
     1086    list f7 = h,m,d[4];
     1087    list f8 = m,h,d[4];
     1088    list f9 = m,n,d[5];
     1089    list f10 = n,m,d[5];
     1090    list v1 = i,1,f1;
     1091    list v2 = j,2,f2,f3;
     1092    list v3 = k,2,f4,f5;
     1093    list v4 = h,2,f6,f7;
     1094    list v5 = m,2,f8,f9;
     1095    list v6 = n,1,f10;
     1096    G.vertices = v1,v2,v3,v4,v5,v6;
     1097    G.edges = f1,f3,f5,f7,f9;
     1098    return (G);
     1099}
     1100
     1101static proc graph52(list d, int i, int j, int k, int h, int m, int n)
     1102{
     1103    graph G;
     1104    list f1 = i,j,d[1];
     1105    list f2 = j,i,d[1];
     1106    list f3 = j,k,d[2];
     1107    list f4 = k,j,d[2];
     1108    list f5 = k,h,d[3];
     1109    list f6 = h,k,d[3];
     1110    list f7 = h,m,d[4];
     1111    list f8 = m,h,d[4];
     1112    list f9 = h,n,d[5];
     1113    list f10 = n,h,d[5];
     1114    list v1 = i,1,f1;
     1115    list v2 = j,2,f2,f3;
     1116    list v3 = k,2,f4,f5;
     1117    list v4 = h,3,f6,f7,f9;
     1118    list v5 = m,1,f8;
     1119    list v6 = n,1,f10;
     1120    G.vertices = v1,v2,v3,v4,v5,v6;
     1121    G.edges = f1,f3,f5,f7,f9;
     1122    return (G);
     1123}
     1124
     1125static proc graph53(list d, int i, int j, int k, int h, int m, int n)
     1126{
     1127    graph G;
     1128    list f1 = i,j,d[1];
     1129    list f2 = j,i,d[1];
     1130    list f3 = j,k,d[2];
     1131    list f4 = k,j,d[2];
     1132    list f5 = k,h,d[3];
     1133    list f6 = h,k,d[3];
     1134    list f7 = k,m,d[4];
     1135    list f8 = m,k,d[4];
     1136    list f9 = k,n,d[5];
     1137    list f10 = n,k,d[5];
     1138    list v1 = i,1,f1;
     1139    list v2 = j,2,f2,f3;
     1140    list v3 = k,4,f4,f5,f7,f9;
     1141    list v4 = h,1,f6;
     1142    list v5 = m,1,f8;
     1143    list v6 = n,1,f10;
     1144    G.vertices = v1,v2,v3,v4,v5,v6;
     1145    G.edges = f1,f3,f5,f7,f9;
     1146    return (G);
     1147}
     1148
     1149static proc graph54(list d, int i, int j, int k, int h, int m, int n)
     1150{
     1151    graph G;
     1152    list f1 = i,j,d[1];
     1153    list f2 = j,i,d[1];
     1154    list f3 = j,k,d[2];
     1155    list f4 = k,j,d[2];
     1156    list f5 = j,h,d[3];
     1157    list f6 = h,j,d[3];
     1158    list f7 = h,m,d[4];
     1159    list f8 = m,h,d[4];
     1160    list f9 = h,n,d[5];
     1161    list f10 = n,h,d[5];
     1162    list v1 = i,1,f1;
     1163    list v2 = j,3,f2,f3,f5;
     1164    list v3 = k,1,f4;
     1165    list v4 = h,3,f6,f7,f9;
     1166    list v5 = m,1,f8;
     1167    list v6 = n,1,f10;
     1168    G.vertices = v1,v2,v3,v4,v5,v6;
     1169    G.edges = f1,f3,f5,f7,f9;
     1170    return (G);
     1171}
     1172
     1173static proc graph55(list d, int i, int j, int k, int h, int m, int n)
     1174{
     1175    graph G;
     1176    list f1 = i,j,d[1];
     1177    list f2 = j,i,d[1];
     1178    list f3 = j,k,d[2];
     1179    list f4 = k,j,d[2];
     1180    list f5 = k,h,d[3];
     1181    list f6 = h,k,d[3];
     1182    list f7 = k,m,d[4];
     1183    list f8 = m,k,d[4];
     1184    list f9 = h,n,d[5];
     1185    list f10 = n,h,d[5];
     1186    list v1 = i,1,f1;
     1187    list v2 = j,2,f2,f3;
     1188    list v3 = k,3,f4,f5,f7;
     1189    list v4 = h,2,f6,f9;
     1190    list v5 = m,1,f8;
     1191    list v6 = n,1,f10;
     1192    G.vertices = v1,v2,v3,v4,v5,v6;
     1193    G.edges = f1,f3,f5,f7,f9;
     1194    return (G);
     1195}
     1196
     1197static proc graph56(list d, int i, int j, int k, int h, int m, int n)
     1198{
     1199    graph G;
     1200    list f1 = i,j,d[1];
     1201    list f2 = j,i,d[1];
     1202    list f3 = j,k,d[2];
     1203    list f4 = k,j,d[2];
     1204    list f5 = j,h,d[3];
     1205    list f6 = h,j,d[3];
     1206    list f7 = j,m,d[4];
     1207    list f8 = m,j,d[4];
     1208    list f9 = j,n,d[5];
     1209    list f10 = n,j,d[5];
     1210    list v1 = i,1,f1;
     1211    list v2 = j,5,f2,f3,f5,f7,f9;
     1212    list v3 = k,1,f4;
     1213    list v4 = h,1,f6;
     1214    list v5 = m,1,f8;
     1215    list v6 = n,1,f10;
     1216    G.vertices = v1,v2,v3,v4,v5,v6;
     1217    G.edges = f1,f3,f5,f7,f9;
     1218    return (G);
     1219}
     1220
     1221static proc graph61(list d, int i, int j, int k, int h, int m, int n, int p)
     1222{
     1223    graph G;
     1224    list f1 = i,j,d[1];
     1225    list f2 = j,i,d[1];
     1226    list f3 = j,k,d[2];
     1227    list f4 = k,j,d[2];
     1228    list f5 = k,h,d[3];
     1229    list f6 = h,k,d[3];
     1230    list f7 = h,m,d[4];
     1231    list f8 = m,h,d[4];
     1232    list f9 = m,n,d[5];
     1233    list f10 = n,m,d[5];
     1234    list f11 = n,p,d[6];
     1235    list f12 = p,n,d[6];
     1236    list v1 = i,1,f1;
     1237    list v2 = j,2,f2,f3;
     1238    list v3 = k,2,f4,f5;
     1239    list v4 = h,2,f6,f7;
     1240    list v5 = m,2,f8,f9;
     1241    list v6 = n,2,f10,f11;
     1242    list v7 = p,1,f12;
     1243    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1244    G.edges = f1,f3,f5,f7,f9,f11;
     1245    return (G);
     1246}
     1247
     1248static proc graph62(list d, int i, int j, int k, int h, int m, int n, int p)
     1249{
     1250    graph G;
     1251    list f1 = i,j,d[1];
     1252    list f2 = j,i,d[1];
     1253    list f3 = j,k,d[2];
     1254    list f4 = k,j,d[2];
     1255    list f5 = k,h,d[3];
     1256    list f6 = h,k,d[3];
     1257    list f7 = h,m,d[4];
     1258    list f8 = m,h,d[4];
     1259    list f9 = m,n,d[5];
     1260    list f10 = n,m,d[5];
     1261    list f11 = m,p,d[6];
     1262    list f12 = p,m,d[6];
     1263    list v1 = i,1,f1;
     1264    list v2 = j,2,f2,f3;
     1265    list v3 = k,2,f4,f5;
     1266    list v4 = h,2,f6,f7;
     1267    list v5 = m,3,f8,f9,f11;
     1268    list v6 = n,1,f10;
     1269    list v7 = p,1,f12;
     1270    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1271    G.edges = f1,f3,f5,f7,f9,f11;
     1272    return (G);
     1273}
     1274
     1275static proc graph63(list d, int i, int j, int k, int h, int m, int n, int p)
     1276{
     1277    graph G;
     1278    list f1 = i,j,d[1];
     1279    list f2 = j,i,d[1];
     1280    list f3 = j,k,d[2];
     1281    list f4 = k,j,d[2];
     1282    list f5 = k,h,d[3];
     1283    list f6 = h,k,d[3];
     1284    list f7 = h,m,d[4];
     1285    list f8 = m,h,d[4];
     1286    list f9 = h,n,d[5];
     1287    list f10 = n,h,d[5];
     1288    list f11 = n,p,d[6];
     1289    list f12 = p,n,d[6];
     1290    list v1 = i,1,f1;
     1291    list v2 = j,2,f2,f3;
     1292    list v3 = k,2,f4,f5;
     1293    list v4 = h,3,f6,f7,f9;
     1294    list v5 = m,1,f8;
     1295    list v6 = n,2,f10,f11;
     1296    list v7 = p,1,f12;
     1297    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1298    G.edges = f1,f3,f5,f7,f9,f11;
     1299    return (G);
     1300}
     1301
     1302static proc graph64(list d, int i, int j, int k, int h, int m, int n, int p)
     1303{
     1304    graph G;
     1305    list f1 = i,j,d[1];
     1306    list f2 = j,i,d[1];
     1307    list f3 = j,k,d[2];
     1308    list f4 = k,j,d[2];
     1309    list f5 = k,h,d[3];
     1310    list f6 = h,k,d[3];
     1311    list f7 = h,m,d[4];
     1312    list f8 = m,h,d[4];
     1313    list f9 = h,n,d[5];
     1314    list f10 = n,h,d[5];
     1315    list f11 = h,p,d[6];
     1316    list f12 = p,h,d[6];
     1317    list v1 = i,1,f1;
     1318    list v2 = j,2,f2,f3;
     1319    list v3 = k,2,f4,f5;
     1320    list v4 = h,4,f6,f7,f9,f11;
     1321    list v5 = m,1,f8;
     1322    list v6 = n,1,f10;
     1323    list v7 = p,1,f12;
     1324    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1325    G.edges = f1,f3,f5,f7,f9,f11;
     1326    return (G);
     1327}
     1328
     1329static proc graph65(list d, int i, int j, int k, int h, int m, int n, int p)
     1330{
     1331    graph G;
     1332    list f1 = i,j,d[1];
     1333    list f2 = j,i,d[1];
     1334    list f3 = j,k,d[2];
     1335    list f4 = k,j,d[2];
     1336    list f5 = k,h,d[3];
     1337    list f6 = h,k,d[3];
     1338    list f7 = k,m,d[4];
     1339    list f8 = m,k,d[4];
     1340    list f9 = k,n,d[5];
     1341    list f10 = n,k,d[5];
     1342    list f11 = n,p,d[6];
     1343    list f12 = p,n,d[6];
     1344    list v1 = i,1,f1;
     1345    list v2 = j,2,f2,f3;
     1346    list v3 = k,4,f4,f5,f7,f9;
     1347    list v4 = h,1,f6;
     1348    list v5 = m,1,f8;
     1349    list v6 = n,2,f10,f11;
     1350    list v7 = p,1,f12;
     1351    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1352    G.edges = f1,f3,f5,f7,f9,f11;
     1353    return (G);
     1354}
     1355
     1356static proc graph66(list d, int i, int j, int k, int h, int m, int n, int p)
     1357{
     1358    graph G;
     1359    list f1 = i,j,d[1];
     1360    list f2 = j,i,d[1];
     1361    list f3 = j,k,d[2];
     1362    list f4 = k,j,d[2];
     1363    list f5 = k,h,d[3];
     1364    list f6 = h,k,d[3];
     1365    list f7 = k,m,d[4];
     1366    list f8 = m,k,d[4];
     1367    list f9 = h,n,d[5];
     1368    list f10 = n,h,d[5];
     1369    list f11 = m,p,d[6];
     1370    list f12 = p,m,d[6];
     1371    list v1 = i,1,f1;
     1372    list v2 = j,2,f2,f3;
     1373    list v3 = k,3,f4,f5,f7;
     1374    list v4 = h,2,f6,f9;
     1375    list v5 = m,1,f8,f11;
     1376    list v6 = n,1,f10;
     1377    list v7 = p,1,f12;
     1378    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1379    G.edges = f1,f3,f5,f7,f9,f11;
     1380    return (G);
     1381}
     1382
     1383static proc graph67(list d, int i, int j, int k, int h, int m, int n, int p)
     1384{
     1385    graph G;
     1386    list f1 = i,j,d[1];
     1387    list f2 = j,i,d[1];
     1388    list f3 = j,k,d[2];
     1389    list f4 = k,j,d[2];
     1390    list f5 = j,h,d[3];
     1391    list f6 = h,j,d[3];
     1392    list f7 = h,m,d[4];
     1393    list f8 = m,h,d[4];
     1394    list f9 = m,n,d[5];
     1395    list f10 = n,m,d[5];
     1396    list f11 = m,p,d[6];
     1397    list f12 = p,m,d[6];
     1398    list v1 = i,1,f1;
     1399    list v2 = j,3,f2,f3,f5;
     1400    list v3 = k,1,f4;
     1401    list v4 = h,2,f6,f7;
     1402    list v5 = m,3,f8,f9,f11;
     1403    list v6 = n,1,f10;
     1404    list v7 = p,1,f12;
     1405    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1406    G.edges = f1,f3,f5,f7,f9,f11;
     1407    return (G);
     1408}
     1409
     1410static proc graph68(list d, int i, int j, int k, int h, int m, int n, int p)
     1411{
     1412    graph G;
     1413    list f1 = i,j,d[1];
     1414    list f2 = j,i,d[1];
     1415    list f3 = j,k,d[2];
     1416    list f4 = k,j,d[2];
     1417    list f5 = j,h,d[3];
     1418    list f6 = h,j,d[3];
     1419    list f7 = h,m,d[4];
     1420    list f8 = m,h,d[4];
     1421    list f9 = h,n,d[5];
     1422    list f10 = n,h,d[5];
     1423    list f11 = h,p,d[6];
     1424    list f12 = p,h,d[6];
     1425    list v1 = i,1,f1;
     1426    list v2 = j,3,f2,f3,f5;
     1427    list v3 = k,1,f4;
     1428    list v4 = h,4,f6,f7,f9,f11;
     1429    list v5 = m,1,f8;
     1430    list v6 = n,1,f10;
     1431    list v7 = p,1,f12;
     1432    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1433    G.edges = f1,f3,f5,f7,f9,f11;
     1434    return (G);
     1435}
     1436
     1437static proc graph69(list d, int i, int j, int k, int h, int m, int n, int p)
     1438{
     1439    graph G;
     1440    list f1 = i,j,d[1];
     1441    list f2 = j,i,d[1];
     1442    list f3 = j,k,d[2];
     1443    list f4 = k,j,d[2];
     1444    list f5 = j,h,d[3];
     1445    list f6 = h,j,d[3];
     1446    list f7 = h,m,d[4];
     1447    list f8 = m,h,d[4];
     1448    list f9 = h,n,d[5];
     1449    list f10 = n,h,d[5];
     1450    list f11 = n,p,d[6];
     1451    list f12 = p,n,d[6];
     1452    list v1 = i,1,f1;
     1453    list v2 = j,3,f2,f3,f5;
     1454    list v3 = k,1,f4;
     1455    list v4 = h,3,f6,f7,f9;
     1456    list v5 = m,1,f8;
     1457    list v6 = n,2,f10,f11;
     1458    list v7 = p,1,f12;
     1459    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1460    G.edges = f1,f3,f5,f7,f9,f11;
     1461    return (G);
     1462}
     1463
     1464static proc graph610(list d, int i, int j, int k, int h, int m, int n, int p)
     1465{
     1466    graph G;
     1467    list f1 = i,j,d[1];
     1468    list f2 = j,i,d[1];
     1469    list f3 = j,k,d[2];
     1470    list f4 = k,j,d[2];
     1471    list f5 = k,h,d[3];
     1472    list f6 = h,k,d[3];
     1473    list f7 = k,m,d[4];
     1474    list f8 = m,k,d[4];
     1475    list f9 = k,n,d[5];
     1476    list f10 = n,k,d[5];
     1477    list f11 = k,p,d[6];
     1478    list f12 = p,k,d[6];
     1479    list v1 = i,1,f1;
     1480    list v2 = j,2,f2,f3;
     1481    list v3 = k,5,f4,f5,f7,f9,f11;
     1482    list v4 = h,1,f6;
     1483    list v5 = m,1,f8;
     1484    list v6 = n,1,f10;
     1485    list v7 = p,1,f12;
     1486    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1487    G.edges = f1,f3,f5,f7,f9,f11;
     1488    return (G);
     1489}
     1490
     1491static proc graph611(list d, int i, int j, int k, int h, int m, int n, int p)
     1492{
     1493    graph G;
     1494    list f1 = i,j,d[1];
     1495    list f2 = j,i,d[1];
     1496    list f3 = j,k,d[2];
     1497    list f4 = k,j,d[2];
     1498    list f5 = j,h,d[3];
     1499    list f6 = h,j,d[3];
     1500    list f7 = j,m,d[4];
     1501    list f8 = m,j,d[4];
     1502    list f9 = j,n,d[5];
     1503    list f10 = n,j,d[5];
     1504    list f11 = j,p,d[6];
     1505    list f12 = p,j,d[6];
     1506    list v1 = i,1,f1;
     1507    list v2 = j,6,f2,f3,f5,f7,f9,f11;
     1508    list v3 = k,1,f4;
     1509    list v4 = h,1,f6;
     1510    list v5 = m,1,f8;
     1511    list v6 = n,1,f10;
     1512    list v7 = p,1,f12;
     1513    G.vertices = v1,v2,v3,v4,v5,v6,v7;
     1514    G.edges = f1,f3,f5,f7,f9,f11;
     1515    return (G);
    771516}
    781517
     
    801519/// Auxilary Static Procedures in this Library /////////////////////////////////
    811520////////////////////////////////////////////////////////////////////////////////
    82 //////// - part     ////////////////////////////////////////////////////////////
    83 //////// - parts    ////////////////////////////////////////////////////////////
    84 //////// - logg     ////////////////////////////////////////////////////////////
    85 //////// - expp     ////////////////////////////////////////////////////////////
    86 //////// - adams    ////////////////////////////////////////////////////////////
    87 //////// - wedges   ////////////////////////////////////////////////////////////
    88 //////// - schur    ////////////////////////////////////////////////////////////
    89 ////////////////////////////////////////////////////////////////////////////////
    901521
    911522proc part(poly f, int n)
    921523"USAGE:     part(f,n); f poly, n int
    931524RETURN:     poly
    94 PURPOSE:    return the homogeneous component of degree n of the polynomial f.
     1525PURPOSE:    computing the homogeneous component of a polynomial.
    951526EXAMPLE:    example part; shows examples
    961527"
     
    1211552"USAGE:     parts(f,i,j); f poly, i int, j int
    1221553RETURN:     poly
    123 PURPOSE:    return a polynomial which is the sum of the homogeneous components
    124             of degree from i to j of the polynomial f.
     1554THEORY:     computing a polynomial which is the sum of the homogeneous
     1555            components of a polynomial.
    1251556EXAMPLE:    example parts; shows examples
    1261557"
     
    1411572    parts(f,2,4);
    1421573}
     1574
    1431575proc logg(poly f, int n)
    1441576"USAGE:     logg(f,n); f poly, n int
    1451577RETURN:     poly
    146 PURPOSE:    computing the Chern character from the total Chern class.
     1578THEORY:     computing Chern characters from total Chern classes.
    1471579EXAMPLE:    example logg; shows examples
    1481580"
     
    1841616"USAGE:     expp(f,n); f poly, n int
    1851617RETURN:     poly
    186 PURPOSE:    computing the total Chern class from the Chern character.
     1618PURPOSE:    computing total Chern classes from Chern characters.
    1871619EXAMPLE:    example expp; shows examples
    1881620"
     
    2691701
    2701702////////////////////////////////////////////////////////////////////////////////
    271 //////// Procedures concerned with varieties ///////////////////////////////////
     1703//////// Procedures concerned with abstract varieties //////////////////////////
    2721704////////////////////////////////////////////////////////////////////////////////
    2731705
    274 proc variety_print(variety V)
     1706proc printVariety(variety V)
     1707"USAGE:     printVariety(V); V variety
     1708ASSUME:     V is an abstract variety
     1709THEORY:     This is the print function used by Singular to print an abstract
     1710            variety.
     1711KEYWORDS:   abstract variety, projective space, Grassmannian
     1712EXAMPLE:    example printVariety; shows an example
     1713"
    2751714{
    2761715    "A variety of dimension", V.dimension;
    2771716}
     1717example
     1718{
     1719    "EXAMPLE:"; echo=2;
     1720    ring r = 0, (h,e), wp(1,1);
     1721    ideal rels = he,h2+e2;
     1722    variety V = makeVariety(2,rels);
     1723    V;
     1724}
    2781725
    2791726proc makeVariety(int d, ideal i)
     1727"USAGE:     makeVariety(d,i); d int, i ideal
     1728ASSUME:     d is a nonnegative integer, i is an ideal
     1729RETURN:     variety
     1730THEORY:     create an abstract variety which has dimension d, and its Chow ring
     1731            should be a quotient ring
     1732KEYWORDS:   abstract variety, projective space, Grassmannian
     1733EXAMPLE:    example makeVariety; shows an example
     1734"
    2801735{
    2811736    def R = basering;
     
    2861741    return(V);
    2871742}
    288 
    289 proc dimension(variety V)
    290 {
    291     return (V.dimension);
     1743example
     1744{
     1745    "EXAMPLE:"; echo=2;
     1746    ring r = 0, (h,e), wp(1,1);
     1747    ideal rels = he,h2+e2;
     1748    variety V = makeVariety(2,rels);
     1749    V;
     1750    V.dimension;
     1751    V.relations;
    2921752}
    2931753
    2941754proc ChowRing(variety V)
     1755"USAGE:     ChowRing(V); V variety
     1756ASSUME:     V is an abstract variety
     1757RETURN:     qring
     1758KEYWORDS:   Chow ring, abstract variety, projective space, Grassmannian
     1759EXAMPLE:    example makeVariety; shows an example
     1760"
    2951761{
    2961762    def R = V.baseRing;
     
    3001766    return (CR);
    3011767}
    302 
    303 proc relations(variety V)
    304 {
    305     def R = V.baseRing;
    306     setring R;
    307     ideal i = V.relations;
    308     return (i);
     1768example
     1769{
     1770    "EXAMPLE:"; echo=2;
     1771    ring r = 0, (h,e), wp(1,1);
     1772    ideal rels = he,h2+e2;
     1773    int d = 2;
     1774    variety V = makeVariety(2,rels);
     1775    ChowRing(V);
    3091776}
    3101777
     
    3141781"USAGE:     Grassmannian(k,n); k int, n int
    3151782RETURN:     variety
    316 PURPOSE:    create a variety as a Grassmannian G(k,n). This variety has
    317             diemnsion k(n-k) and its Chow ring is the quotient ring of a
    318             polynomial ring in n-k variables q(1),...,q(n-k) which are the
    319             Chern classes of the tautological quotient bundle on the
    320             Grassmannian G(k,n), modulo the ideal generated by n-k polynomials
    321             which come from the Giambelli formula. The monomial ordering of this
    322             ring is 'wp' with vector (1..k,1..n-k). Moreover, we export the
    323             Chern characters of the tautological subbundle and quotient bundle
    324             on G(k,n) (say 'subBundle' and 'quotientBundle').
     1783THEORY:     create a Grassmannian G(k,n) as an abstract variety. This abstract
     1784            variety has diemnsion k(n-k) and its Chow ring is the quotient ring
     1785            of a polynomial ring in n-k variables q(1),...,q(n-k), which are the
     1786            Chern classes of tautological quotient bundle on G(k,n), modulo some
     1787            ideal generated by n-k polynomials which come from the Giambelli
     1788            formula. The monomial ordering of this Chow ring is 'wp' with vector
     1789            (1..k,1..n-k). Moreover, we export the Chern characters of
     1790            tautological subbundle and quotient bundle on G(k,n)
     1791            (say 'subBundle' and 'quotientBundle').
     1792KEYWORDS:   Grassmannian, abstract variety, Schubert calculus
     1793SEE ALSO:   projectiveSpace, projectiveBundle
    3251794EXAMPLE:    example Grassmannian; shows examples
    3261795"
     
    3681837{
    3691838    "EXAMPLE:"; echo=2;
    370     def G24 = Grassmannian(2,4);
     1839    variety G24 = Grassmannian(2,4);
    3711840    G24;
    3721841    def r = G24.baseRing;
     1842    setring r;
    3731843    subBundle;
    3741844    quotientBundle;
     
    3811851"USAGE:     projectiveSpace(n); n int
    3821852RETURN:     variety
    383 PURPOSE:    create a variety as a projective space of dimension n. The Chow ring
    384             is the quotient ring in one variable h modulo the ideal generated by
    385             h^(n+1).
     1853THEORY:     create a projective space of dimension n as an abstract variety. Its
     1854            Chow ring is a quotient ring in one variable h modulo the ideal
     1855            generated by h^(n+1).
     1856KEYWORDS:   projective space, abstract variety
     1857SEE ALSO:   Grassmannian, projectiveBundle
    3861858EXAMPLE:    example projectiveSpace; shows examples
    3871859"
     
    4191891{
    4201892    "EXAMPLE:"; echo=2;
    421     def P = projectiveSpace(3);
     1893    variety P = projectiveSpace(3);
    4221894    P;
    4231895    P.dimension;
     
    4301902proc projectiveBundle(sheaf S, list #)
    4311903"USAGE:     projectiveBundle(S); S sheaf
     1904INPUT:      a sheaf on an abstract variety
    4321905RETURN:     variety
    433 PURPOSE:    create a variety which we work on.
     1906THEORY:     create a projective bundle as an abstract variety. This is related
     1907            to the enumeration of conics.
     1908KEYWORDS:   projective bundle, abstract variety, sheaf, enumeration of conics
     1909SEE ALSO:   projectiveSpace, Grassmannian
    4341910EXAMPLE:    example projectiveBundle; shows examples
    4351911"
     
    4701946{
    4711947    "EXAMPLE:"; echo=2;
    472     def G35 = Grassmannian(3,5);
    473     def R = G35.baseRing;
     1948    variety G = Grassmannian(3,5);
     1949    def r = G.baseRing;
     1950    setring r;
     1951    sheaf S = makeSheaf(G,subBundle);
     1952    sheaf B = dualSheaf(S)^2;
     1953    variety PB = projectiveBundle(B);
     1954    PB;
     1955    def R = PB.baseRing;
    4741956    setring R;
    475     def S = makeSheaf(G35, subBundle);
    476     def B = symmetricPowerSheaf(dualSheaf(S),2);
    477     def PB = projectiveBundle(B);
    478     PB;
    479     def P = PB.baseRing;
    480     setring P;
    4811957    QuotientBundle;
    4821958    ChowRing(PB);
     
    4841960
    4851961proc productVariety(variety U, variety V)
     1962"USAGE:     productVariety(U,V); U variety, V variety
     1963INPUT:      two abstract varieties
     1964OUTPUT:     a product variety as an abstract variety
     1965RETURN:     variety
     1966KEYWORDS:   product variety, abstract variety
     1967SEE ALSO:   projectiveSpace, Grassmannian, projectiveBundle
     1968EXAMPLE:    example productVariety; shows examples
     1969"
    4861970{
    4871971    //def br = basering;
     
    4981982    ideal i2 = imap(vr,ii2);
    4991983    W.relations = i1 + i2;
     1984    setring ur;
     1985    kill ii1;
     1986    setring vr;
     1987    kill ii2;
    5001988    //setring br;
    5011989    return (W);
    5021990}
     1991example
     1992{
     1993    "EXAMPLE:"; echo=2;
     1994    variety P = projectiveSpace(3);
     1995    variety G = Grassmannian(2,4);
     1996    variety W = productVariety(P,G);
     1997    W;
     1998    W.dimension == P.dimension + G.dimension;
     1999    def r = W.baseRing;
     2000    setring r;
     2001    W.relations;
     2002}
    5032003
    5042004////////////////////////////////////////////////////////////////////////////////
     
    5062006proc integral(variety V, poly f)
    5072007"USAGE:     integral(V,f); V variety, f poly
     2008INPUT:      a abstract variety and a polynomial
    5082009RETURN:     int
    509 PURPOSE:    compute the intersection numbers.
    510 EXAMPLE:    example integral; shows examples
     2010PURPOSE:    computing intersection numbers.
     2011EXAMPLE:    example integral; shows an example
    5112012"
    5122013{
     
    5192020{
    5202021    "EXAMPLE:"; echo=2;
    521     def G24 = Grassmannian(2,4);
    522     def R = G24.baseRing;
    523     setring R;
    524     integral(G24,q(1)^4);
     2022    variety G = Grassmannian(2,4);
     2023    def r = G.baseRing;
     2024    setring r;
     2025    integral(G,q(1)^4);
    5252026}
    5262027
    5272028proc SchubertClass(list p)
    5282029"USAGE:     SchubertClass(p); p list
     2030INPUT:      a list of integers which is a partition
    5292031RETURN:     poly
    530 PURPOSE:    compute the Schubert class on a Grassmannian.
    531 EXAMPLE:    example SchubertClass; shows examples
     2032PURPOSE:    compute the Schubert classes on a Grassmannian.
     2033EXAMPLE:    example SchubertClass; shows an example
    5322034"
    5332035{
     
    5462048{
    5472049    "EXAMPLE:"; echo=2;
    548     def G = Grassmannian(2,4);
     2050    variety G = Grassmannian(2,4);
    5492051    def r = G.baseRing;
    5502052    setring r;
     
    5562058
    5572059proc dualPartition(int k, int n, list p)
     2060"USAGE:     dualPartition(k,n,p); k int, n int, p list
     2061INPUT:      two integers and a partition
     2062RETURN:     list
     2063PURPOSE:    compute the dual of a partition.
     2064SEE ALSO:   SchubertClass
     2065EXAMPLE:    example dualPartition; shows an example
     2066"
    5582067{
    5592068    while (size(p) < k)
     
    5692078    return (l);
    5702079}
    571 
    572 ////////////////////////////////////////////////////////////////////////////////
     2080example
     2081{
     2082    "EXAMPLE:"; echo=2;
     2083    ring r = 0,(x),dp;
     2084    dualPartition(2,4,list(2,1));
     2085}
    5732086
    5742087////////////////////////////////////////////////////////////////////////////////
     
    5762089////////////////////////////////////////////////////////////////////////////////
    5772090
    578 ////////////////////////////////////////////////////////////////////////////////
    579 
    580 proc sheaf_print(sheaf S)
    581 {
    582     def V = S.currentVariety;
    583     def R = V.baseRing;
    584     setring R;
    585     poly f = S.ChernCharacter;
    586     "A sheaf of rank ", int(part(f,0));
     2091proc printSheaf(sheaf S)
     2092"USAGE:     printSheaf(S); S sheaf
     2093RETURN:     string
     2094INPUT:      a sheaf
     2095THEORY:     This is the print function used by Singular to print a sheaf.
     2096SEE ALSO:   makeSheaf, rankSheaf
     2097EXAMPLE:    example printSheaf; shows an example
     2098"
     2099{
     2100    "A sheaf of rank ", rankSheaf(S);
     2101}
     2102example
     2103{
     2104    "EXAMPLE:"; echo=2;
     2105    variety X;
     2106    X.dimension = 4;
     2107    ring r = 0,(c(1..2),d(1..3)),wp(1..2,1..3);
     2108    setring r;
     2109    X.baseRing = r;
     2110    poly c = 1 + c(1) + c(2);
     2111    poly ch = 2 + logg(c,4);
     2112    sheaf S = makeSheaf(X,ch);
     2113    S;
    5872114}
    5882115
    5892116proc makeSheaf(variety V, poly ch)
     2117"USAGE:     makeSheaf(V,ch); V variety, ch poly
     2118RETURN:     sheaf
     2119THEORY:     create a sheaf on an abstract variety, and its Chern character is
     2120            the polynomial ch.
     2121SEE ALSO:   printSheaf, rankSheaf
     2122EXAMPLE:    example makeSheaf; shows an example
     2123"
    5902124{
    5912125    def R = basering;
     
    5952129    return(S);
    5962130}
    597 
    598 proc currentVariety(sheaf S)
    599 {
    600     return (S.currentVariety);
    601 }
    602 
    603 proc ChernCharacter(sheaf S)
    604 {
    605     return (S.ChernCharacter)
     2131example
     2132{
     2133    "EXAMPLE:"; echo=2;
     2134    variety X;
     2135    X.dimension = 4;
     2136    ring r = 0,(c(1..2),d(1..3)),wp(1..2,1..3);
     2137    setring r;
     2138    X.baseRing = r;
     2139    poly c = 1 + c(1) + c(2);
     2140    poly ch = 2 + logg(c,4);
     2141    sheaf S = makeSheaf(X,ch);
     2142    S;
    6062143}
    6072144
     
    6092146"USAGE:     rankSheaf(S); S sheaf
    6102147RETURN:     int
    611 INPUT:      S -- a sheaf
    612 OUTPUT:     an integer which is the rank of the sheaf S.
    613 EXAMPLE:    example rankSheaf(S); shows examples
    614 "
    615 {
    616     def V = S.currentVariety;
     2148INPUT:      S is a sheaf
     2149OUTPUT:     a positive integer which is the rank of a sheaf.
     2150SEE ALSO:   makeSheaf, printSheaf
     2151EXAMPLE:    example rankSheaf; shows an example
     2152"
     2153{
     2154    variety V = S.currentVariety;
    6172155    def R = V.baseRing;
    6182156    setring R;
     
    6232161{
    6242162    "EXAMPLE:"; echo=2;
    625     def G24 = Grassmannian(2,4);
    626     def R = G24.baseRing;
     2163    variety G = Grassmannian(2,4);
     2164    def R = G.baseRing;
    6272165    setring R;
    628     def S = makeSheaf(G24,subBundle);
     2166    sheaf S = makeSheaf(G,subBundle);
    6292167    rankSheaf(S);
    6302168}
    6312169
    6322170proc totalChernClass(sheaf S)
    633 "USAGE:     totalChernClass(S); f sheaf
     2171"USAGE:     totalChernClass(S); S sheaf
    6342172RETURN:     poly
    635 INPUT:      S -- a sheaf
    636 OUTPUT:     a polynomial which is the total Chern class of the sheaf S
    637 EXAMPLE:    example totalChernClass(S); shows examples
    638 "
    639 {
    640     def V = S.currentVariety;
     2173INPUT:      S is a sheaf
     2174OUTPUT:     a polynomial which is the total Chern class of a sheaf
     2175SEE ALSO:   totalSegreClass, topChernClass, ChernClass
     2176EXAMPLE:    example totalChernClass; shows an example
     2177"
     2178{
     2179    variety V = S.currentVariety;
    6412180    int d = V.dimension;
    6422181    def R = V.baseRing;
     
    6472186    return (reduce(f,rels));
    6482187}
     2188example
     2189{
     2190    "EXAMPLE:"; echo=2;
     2191    variety X;
     2192    X.dimension = 4;
     2193    ring r = 0,(c(1..2),d(1..3)),wp(1..2,1..3);
     2194    setring r;
     2195    X.baseRing = r;
     2196    poly c = 1 + c(1) + c(2);
     2197    poly ch = 2 + logg(c,4);
     2198    sheaf E = makeSheaf(X,ch);
     2199    sheaf S = E^3;
     2200    totalChernClass(S);
     2201}
    6492202
    6502203proc ChernClass(sheaf S, int i)
     2204"USAGE:     ChernClass(S,i); S sheaf, i int
     2205INPUT:      S is a sheaf, i is a nonnegative integer
     2206RETURN:     poly
     2207THEORY:     This is the i-th Chern class of a sheaf
     2208SEE ALSO:   topChernClass, totalChernClass
     2209EXAMPLE:    example ChernClass; shows an example
     2210"
    6512211{
    6522212    return (part(totalChernClass(S),i));
     2213}
     2214example
     2215{
     2216    "EXAMPLE:"; echo=2;
     2217    variety X;
     2218    X.dimension = 4;
     2219    ring r = 0,(c(1..2),d(1..3)),wp(1..2,1..3);
     2220    setring r;
     2221    X.baseRing = r;
     2222    poly c = 1 + c(1) + c(2);
     2223    poly ch = 2 + logg(c,4);
     2224    sheaf E = makeSheaf(X,ch);
     2225    sheaf S = E^3;
     2226    ChernClass(S,1);
     2227    ChernClass(S,2);
     2228    ChernClass(S,3);
     2229    ChernClass(S,4);
    6532230}
    6542231
     
    6562233"USAGE:     topChernClass(S); S sheaf
    6572234RETURN:     poly
    658 INPUT:      S -- a sheaf
    659 OUTPUT:     the top Chern class of the sheaf S
    660 EXAMPLE:    example topChernClass(S); shows examples
     2235INPUT:      S is a sheaf
     2236THEORY:     This is the top Chern class of a sheaf
     2237SEE ALSO:   ChernClass, totalChernClass
     2238EXAMPLE:    example topChernClass; shows an example
    6612239"
    6622240{
     
    6662244{
    6672245    "EXAMPLE:"; echo=2;
    668     def G24 = Grassmannian(2,4);
    669     def R = G24.baseRing;
     2246    variety G = Grassmannian(2,4);
     2247    def R = G.baseRing;
    6702248    setring R;
    671     def S = makeSheaf(G24,quotientBundle);
    672     def B = symmetricPowerSheaf(S,3);
     2249    sheaf S = makeSheaf(G,quotientBundle);
     2250    sheaf B = S^3;
    6732251    topChernClass(B);
    6742252}
     
    6772255"USAGE:     totalSegreClass(S); S sheaf
    6782256RETURN:     poly
    679 INPUT:      S -- a sheaf
    680 OUTPUT:     a polynomial which is the total Segre class of the sheaf S.
    681 EXAMPLE:    example totalSegreClass(S); shows examples
     2257INPUT:      S is a sheaf
     2258THEORY:     This is the total Segre class of a sheaf.
     2259SEE AlSO:   totalChernClass
     2260EXAMPLE:    example totalSegreClass; shows an example
    6822261"
    6832262{
    6842263    //def D = dualSheaf(S);
    685     def V = S.currentVariety;
     2264    variety V = S.currentVariety;
    6862265    def R = V.baseRing;
    6872266    setring R;
     
    7032282{
    7042283    "EXAMPLE:"; echo=2;
    705     def G24 = Grassmannian(2,4);
    706     def R = G24.baseRing;
     2284    variety G = Grassmannian(2,4);
     2285    def R = G.baseRing;
    7072286    setring R;
    708     def S = makeSheaf(G24,subBundle);
     2287    sheaf S = makeSheaf(G,subBundle);
    7092288    totalSegreClass(S);
    7102289}
     
    7132292"USAGE:     dualSheaf(S); S sheaf
    7142293RETURN:     sheaf
    715 INPUT:      S -- a sheaf
    716 OUTPUT:     the dual of the sheaf S
    717 EXAMPLE:    example dualSheaf(S); shows examples
    718 "
    719 {
    720     def V = S.currentVariety;
     2294THEORY:     This is the dual of a sheaf
     2295SEE ALSO:   addSheaf, symmetricPowerSheaf, tensorSheaf, quotSheaf
     2296EXAMPLE:    example dualSheaf; shows examples
     2297"
     2298{
     2299    variety V = S.currentVariety;
    7212300    int d = V.dimension;
    7222301    def R = V.baseRing;
     
    7322311{
    7332312    "EXAMPLE:"; echo=2;
    734     def G24 = Grassmannian(2,4);
    735     def R = G24.baseRing;
     2313    variety G = Grassmannian(2,4);
     2314    def R = G.baseRing;
    7362315    setring R;
    737     def S = makeSheaf(G24,subBundle);
    738     dualSheaf(S);
     2316    sheaf S = makeSheaf(G,subBundle);
     2317    sheaf D = dualSheaf(S);
     2318    D;
    7392319}
    7402320
     
    7422322"USAGE:     tensorSheaf(A,B); A sheaf, B sheaf
    7432323RETURN:     sheaf
    744 INPUT:      A, B -- two sheaves
    745 OUTPUT:     the tensor of two sheaves A and B
    746 EXAMPLE:    example tensorSheaf(A,B); shows examples
     2324THEORY:     This is the tensor product of two sheaves
     2325SEE ALSO:   addSheaf, symmetricPowerSheaf, quotSheaf, dualSheaf
     2326EXAMPLE:    example tensorSheaf; shows examples
    7472327"
    7482328{
    7492329    sheaf S;
    750     def V1 = A.currentVariety;
    751     def V2 = B.currentVariety;
     2330    variety V1 = A.currentVariety;
     2331    variety V2 = B.currentVariety;
    7522332    def R1 = V1.baseRing;
    7532333    setring R1;
     
    7772357{
    7782358    "EXAMPLE:"; echo=2;
    779     def G34 = Grassmannian(3,4);
    780     def R = G34.baseRing;
     2359    variety G = Grassmannian(3,4);
     2360    def R = G.baseRing;
    7812361    setring R;
    782     def S = makeSheaf(G34,subBundle);
    783     def Q = makeSheaf(G34, quotientBundle);
    784     S*Q;
     2362    sheaf S = makeSheaf(G,subBundle);
     2363    sheaf Q = makeSheaf(G,quotientBundle);
     2364    sheaf T = S*Q;
     2365    T;
    7852366}
    7862367
     
    7882369"USAGE:     symmetricPowerSheaf(S,n); S sheaf, n int
    7892370RETURN:     sheaf
    790 INPUT:      S -- a sheaf
    791             n -- an integer
    792 OUTPUT:     the n-th symmetric power of the sheaf S
    793 EXAMPLE:    example symmetricPowerSheaf(S,n); shows examples
    794 "
    795 {
    796     def V = S.currentVariety;
     2371THEORY:     This is the n-th symmetric power of a sheaf
     2372SEE ALSO:   quotSheaf, addSheaf, tensorSheaf, dualSheaf
     2373EXAMPLE:    example symmetricPowerSheaf; shows examples
     2374"
     2375{
     2376    variety V = S.currentVariety;
    7972377    def R = V.baseRing;
    7982378    setring R;
     
    8312411{
    8322412    "EXAMPLE:"; echo=2;
    833     def G24 = Grassmannian(2,4);
    834     def R = G24.baseRing;
     2413    variety G = Grassmannian(2,4);
     2414    def R = G.baseRing;
    8352415    setring R;
    836     def S = makeSheaf(G24,quotientBundle);
    837     def B = symmetricPowerSheaf(S,3);
     2416    sheaf S = makeSheaf(G,quotientBundle);
     2417    sheaf B = symmetricPowerSheaf(S,3);
    8382418    B;
    839 }
    840 
    841 proc minusSheaf(sheaf A, sheaf B)
     2419    sheaf A = S^3;
     2420    A;
     2421    A.ChernCharacter == B.ChernCharacter;
     2422}
     2423
     2424proc quotSheaf(sheaf A, sheaf B)
     2425"USAGE:     quotSheaf(A,B); A sheaf, B sheaf
     2426RETURN:     sheaf
     2427THEORY:     This is the quotient of two sheaves
     2428SEE ALSO:   addSheaf, symmetricPowerSheaf, tensorSheaf, dualSheaf
     2429EXAMPLE:    example quotSheaf; shows an example
     2430"
    8422431{
    8432432    sheaf S;
    844     def V1 = A.currentVariety;
    845     def V2 = B.currentVariety;
     2433    variety V1 = A.currentVariety;
     2434    variety V2 = B.currentVariety;
    8462435    def R1 = V1.baseRing;
    8472436    setring R1;
     
    8662455    }
    8672456}
    868 
    869 proc plusSheaf(sheaf A, sheaf B)
     2457example
     2458{
     2459    "EXAMPLE:"; echo=2;
     2460    variety G = Grassmannian(3,5);
     2461    def r = G.baseRing;
     2462    setring r;
     2463    sheaf S = makeSheaf(G,subBundle);
     2464    sheaf B = dualSheaf(S)^2;
     2465    sheaf B3 = dualSheaf(S)^3;
     2466    sheaf B5 = dualSheaf(S)^5;
     2467    variety PB = projectiveBundle(B);
     2468    def R = PB.baseRing;
     2469    setring R;
     2470    sheaf Q = makeSheaf(PB,QuotientBundle);
     2471    sheaf V = dualSheaf(Q)*B3;
     2472    sheaf A = B5 - V;
     2473    A;
     2474}
     2475
     2476proc addSheaf(sheaf A, sheaf B)
     2477"USAGE:     addSheaf(A,B); A sheaf, B sheaf
     2478RETURN:     sheaf
     2479THEORY:     This is the direct sum of two sheaves.
     2480SEE ALSO:   quotSheaf, symmetricPowerSheaf, tensorSheaf, dualSheaf
     2481EXAMPLE:    example addSheaf; shows an example
     2482"
    8702483{
    8712484    sheaf S;
    872     def V1 = A.currentVariety;
    873     def V2 = B.currentVariety;
     2485    variety V1 = A.currentVariety;
     2486    variety V2 = B.currentVariety;
    8742487    def R1 = V1.baseRing;
    8752488    setring R1;
     
    8942507    }
    8952508}
    896 
    897 ////////////////////////////////////////////////////////////////////////////////
    898 
    899 proc geometricMultiplicity(ideal I, ideal J)
    900 "USAGE:     geometricMultiplicity(I,J); I,J = ideals
    901 RETURN:     int
    902 INPUT:      I, J -- two ideals
    903 OTPUT:      an integer which is the intersection multiplicity of two subvarieties
    904             defined by the ideals I, J at the origin.
    905 EXAMPLE:    example geometricMultiplicity(I,J); shows examples
    906 "
    907 {
    908     def R = basering;
    909     setring R;
    910     ideal K = I + J;
    911     int v = vdim(std(K));
    912     return (v);
    913 }
    914 example
    915 {
    916     "EXAMPLE:"; echo=2;
    917     ring r = 0, (x,y,z,w), ds;
    918     ideal I = xz,xw,yz,yw;
    919     ideal J = x-z,y-w;
    920     geometricMultiplicity(I,J);
    921 }
    922 
    923 ////////////////////////////////////////////////////////////////////////////////
    924 
    925 proc serreMultiplicity(ideal I, ideal J)
    926 "USAGE:     serreMultiplicity(I,J); I,J = ideals
    927 RETURN:     int
    928 INPUT:      I, J -- two ideals
    929 OUTPUT:     the intersection multiplicity (defined by J. P. Serre)
    930             of two subvarieties defined by the ideals I, J at the origin.
    931 EXAMPLE:    example serreMultiplicity(I,J); shows examples
    932 "
    933 {
    934     def R = basering;
    935     setring R;
    936     int i = 0;
    937     int s = 0;
    938     module m = std(Tor(i,I,J));
    939     int t = sum(hilb(m,2));
    940     kill m;
    941     while (t != 0)
    942     {
    943         s = s + ((-1)^i)*t;
    944         i++;
    945         module m = std(Tor(i,I,J));
    946         t = sum(hilb(m,2));
    947         kill m;
    948     }
    949     return (s);
    950 }
    951 example
    952 {
    953     "EXAMPLE:"; echo=2;
    954     ring r = 0, (x,y,z,w), ds;
    955     ideal I = xz,xw,yz,yw;
    956     ideal J = x-z,y-w;
    957     serreMultiplicity(I,J);
    958 }
     2509example
     2510{
     2511    "EXAMPLE:"; echo=2;
     2512    variety G = Grassmannian(3,5);
     2513    def r = G.baseRing;
     2514    setring r;
     2515    sheaf S = makeSheaf(G,subBundle);
     2516    sheaf Q = makeSheaf(G,quotientBundle);
     2517    sheaf D = S + Q;
     2518    D;
     2519    D.ChernCharacter == rankSheaf(D);
     2520    totalChernClass(D) == 1;
     2521}
  • Singular/Makefile.am

    r93c5cf r906feb  
    2626
    2727AM_CPPFLAGS = -I${top_srcdir} -I${top_builddir} -I${top_srcdir}/numeric -I${top_builddir}/numeric -I${top_srcdir}/kernel -I${top_builddir}/kernel -I${top_srcdir}/libpolys -I${top_builddir}/libpolys $(GMP_CFLAGS) -I${top_srcdir}/factory/include -I${top_builddir}/factory/include $(FACTORY_CFLAGS) $(NTL_CFLAGS) $(FLINT_CFLAGS) -DHAVE_CONFIG_H  -DGIT_VERSION='"$(GIT_VERSION)"'
    28 AMLDFLAGS = -L${top_builddir}/Singular -L${top_builddir}/numeric -L${top_builddir}/kernel -L${top_builddir}/libpolys/polys  -L${top_builddir}/libpolys/coeffs -L${top_builddir}/libpolys/reporter -L${top_builddir}/libpolys/misc $(USE_FACTORY) -L${top_builddir}/omalloc -L${top_builddir}/resources
     28AM_LDFLAGS = -L${top_builddir}/Singular -L${top_builddir}/numeric -L${top_builddir}/kernel -L${top_builddir}/libpolys/polys  -L${top_builddir}/libpolys/coeffs -L${top_builddir}/libpolys/reporter -L${top_builddir}/libpolys/misc $(USE_FACTORY) -L${top_builddir}/omalloc -L${top_builddir}/resources
    2929
    3030########################### Dynamic Modules... #########################
     
    5656
    5757pyobject_la_LIBS    = $(PYTHON_EXTRA_LIBS)
    58 pyobject_la_LDFLAGS = ${AMLDFLAGS} $(PYTHON_EXTRA_LDFLAGS) $(PYTHON_LDFLAGS) $(PYTHON_LSPEC) -module -export-dynamic -avoid-version -flat_namespace -weak_reference_mismatches weak -undefined dynamic_lookup
     58pyobject_la_LDFLAGS = ${AM_LDFLAGS} $(PYTHON_EXTRA_LDFLAGS) $(PYTHON_LDFLAGS) $(PYTHON_LSPEC) -module -export-dynamic -avoid-version -flat_namespace -weak_reference_mismatches weak -undefined dynamic_lookup
    5959###  -export-dynamic -shared -module -avoid-version (add to all DMs?)
    6060
     
    207207# nodist_libSingular_g_la_SOURCES = iparith.inc
    208208
    209 libSingular_la_LDFLAGS    =  -release ${PACKAGE_VERSION} ${AMLDFLAGS} ${EMBED_PYOBJECT} \
     209libSingular_la_LDFLAGS    =  -release ${PACKAGE_VERSION} ${AM_LDFLAGS} ${EMBED_PYOBJECT} \
    210210-lnumeric -lkernel -lpolys -lcoeffs -lreporter -lmisc \
    211211$(FACTORY_LIBS) -lomalloc -lresources $(FLINT_LIBS) $(NTL_LIBS) $(GMP_LIBS) ${USEPPROCSDYNAMICLDFLAGS} ${USEPPROCSDYNAMICLD}
     
    285285# Singular_CPPFLAGS = ${AM_CPPFLAGS} -DHAVE_CONFIG_H
    286286
    287 Singular_LDFLAGS = -static ${AMLDFLAGS}
    288 # Singularg_LDFLAGS = -static ${AMLDFLAGS}
     287Singular_LDFLAGS = -static ${AM_LDFLAGS}
     288# Singularg_LDFLAGS = -static ${AM_LDFLAGS}
    289289
    290290
     
    312312# Singulard_CPPFLAGS = ${AM_CPPFLAGS} -DHAVE_CONFIG_H
    313313
    314 Singulard_LDFLAGS = ${AMLDFLAGS}
    315 # Singulardg_LDFLAGS = ${AMLDFLAGS}
     314Singulard_LDFLAGS = ${AM_LDFLAGS}
     315# Singulardg_LDFLAGS = ${AM_LDFLAGS}
    316316
    317317
     
    322322#ESingular_CPPFLAGS = ${AM_CPPFLAGS} -DHAVE_CONFIG_H -DNDEBUG -DOM_NDEBUG -DESINGULAR -DPROTO
    323323ESingular_CPPFLAGS = ${AM_CPPFLAGS} -DESINGULAR -DPROTO
    324 ESingular_LDFLAGS = -static ${AMLDFLAGS}
     324ESingular_LDFLAGS = -static ${AM_LDFLAGS}
    325325ESingular_LDADD =   -lreporter -lmisc -lomalloc -lresources
    326326
     
    333333#TSingular_CPPFLAGS = ${AM_CPPFLAGS} -DHAVE_CONFIG_H -DNDEBUG -DOM_NDEBUG -DTSINGULAR -DPROTO
    334334TSingular_CPPFLAGS = ${AM_CPPFLAGS} -DTSINGULAR -DPROTO
    335 TSingular_LDFLAGS = -static ${AMLDFLAGS}
     335TSingular_LDFLAGS = -static ${AM_LDFLAGS}
    336336TSingular_LDADD =   -lreporter -lmisc -lomalloc -lresources
    337337
     
    351351# # libSingular.la -lnumeric
    352352libparse_LDADD = -lomalloc
    353 libparse_LDFLAGS = -static ${AMLDFLAGS}
     353libparse_LDFLAGS = -static ${AM_LDFLAGS}
    354354# TODO for libparse:
    355355# multiple definition of `category_out': libparse.cc v.s. utils.cc
     
    419419#test_s_g_CPPFLAGS = ${AM_CPPFLAGS} -DHAVE_CONFIG_H
    420420
    421 test_s_r_LDFLAGS = -static ${AMLDFLAGS}
    422 #test_s_g_LDFLAGS = -static ${AMLDFLAGS}
     421test_s_r_LDFLAGS = -static ${AM_LDFLAGS}
     422#test_s_g_LDFLAGS = -static ${AM_LDFLAGS}
    423423
    424424
     
    442442# test_d_g_CPPFLAGS = ${AM_CPPFLAGS} -DHAVE_CONFIG_H
    443443
    444 #test_d_r_LDFLAGS = ${AMLDFLAGS}
    445 # test_d_g_LDFLAGS = ${AMLDFLAGS}
     444#test_d_r_LDFLAGS = ${AM_LDFLAGS}
     445# test_d_g_LDFLAGS = ${AM_LDFLAGS}
    446446
    447447#########################################################
  • Singular/blackbox.cc

    r93c5cf r906feb  
    8383  {
    8484    l->data=omStrDup(getBlackboxName(r->Typ()));
     85    l->rtyp=STRING_CMD;
     86    return FALSE;
     87  }
     88  else if (op==NAMEOF_CMD)
     89  {
     90    if (r->name==NULL) l->data=omStrDup("");
     91    else               l->data=omStrDup(r->name);
    8592    l->rtyp=STRING_CMD;
    8693    return FALSE;
  • Singular/fehelp.cc

    r93c5cf r906feb  
    10521052                   break;
    10531053                 }
     1054        case 'v': /* version number*/
     1055                 {
     1056                   char temp[256];
     1057                   sprintf(temp,"%d-%d-%d",SINGULAR_VERSION/1000,
     1058                                 (SINGULAR_VERSION % 1000)/100,
     1059                                 (SINGULAR_VERSION % 100));
     1060                   strcat(sys,temp);
     1061                   i=strlen(sys);
     1062                   break;
     1063                 }
    10541064        default: break;
    10551065      }
  • Singular/links/ssiLink.cc

    r93c5cf r906feb  
    12941294    int tt=data->Typ();
    12951295    void *dd=data->Data();
     1296    if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
     1297      // return pure undefined names as def
    12961298
    12971299    switch(tt /*data->Typ()*/)
  • Singular/singular-libs

    r93c5cf r906feb  
    4545        locnormal.lib modnormal.lib \
    4646        JMBTest.lib JMSConst.lib multigrading.lib parallel.lib realizationMatroids.lib ringgb.lib \
    47         schreyer.lib symodstd.lib derham.lib polybori.lib ellipticcovers.lib
     47        schreyer.lib symodstd.lib derham.lib polybori.lib ellipticcovers.lib \
     48        schubert.lib
    4849
    4950PLIBS = bfun.lib central.lib dmod.lib dmodapp.lib dmodvar.lib fpadim.lib \
  • Tst/Manual/Tracing_of_procedures.res.gz.uu

    r93c5cf r906feb  
    1 begin 664 Tracing_of_procedures.res.gz
    2 M'XL("$]E(E$``U1R86-I;F=?;V9?<')O8V5D=7)E<RYR97,`[55-B]LP$+WG
    3 M5XBEA^30X)%D2<&LH=\LE!XVN8=TJ[8"URFQLDL1_N_5<]9:J^WVG$,N+WH:
    4 MZ<T\3?"L-V]O/C'&J&8?;UZS*]_Y9>,^7U4LKK:N=7Z^J&;X977--H?=G6N_
    5 M;?=?MS\/^SO[Y7BPW;*U#\O.[_QL_2C&ZP@XP#RE3;&,$!*5H(RYUC-WS:NT
    6 MKT[[#]]=8]G<U<4BA<PI%.(%]Y(JUH\1*A!YHH3\F]M7;]Y=BZ1,0U6>X&=F
    7 M6V\/T4GD;-[8>]NPF"A0'W@?1!]D'\H151_T7^O3PO2SQN[N(90KC3E%/;PC
    8 M7N?8S6E1O9CF3I%I#;R(\KPH`0J@`28"E1DM5MC#8<(Y0H!6.37C'B\`\,<Y
    9 M0`!,3B'%=4Z1DJL4&&Y`3T!*X*[`88'#0N6T3'NZ?W+-)KZW^Z,?O1/>7\?C
    10 MI#7``&(J,@6``#*G/)-]%/[5>?MC%.51%*6B4E2&PE`7RHI5!1&SB)A$1E')
    11 M)VLZ<2DF'7X^!1F1RBO_*.J#]9O.KP>_[X<_]>2>BK60@FD%TPI^-0QJ&-1B
    12 M0O,Z_JMJ(&AT=N7Y1^?Q$2[M.>/VK"[M.>/VP#"'8R[QZ1OII65GW#*>NH5!
    13 >)3&H)$:;Q&@KT<$2#2WY=+[_:UK_!FO`_UL_"0``
     1begin 644 Tracing_of_procedures.res.gz
     2M'XL("*@<55(``U1R86-I;F=?;V9?<')O8V5D=7)E<RYR97,`[55-C],P$+WW
     3M5U@K#NV!*F,[L:MH(_&ME1`'VGM5%@.60HH:=U<HRG]G7MJ8&%C./?3RZO'8
     4M;][S5)GUYO7=!R$$5>+]W4MQ$]JPK/VGFU+P:NL;'^:+<H9?455B<]C=^^;K
     5M=O]E^^.POW>?CP?7+AOWN&S#+LS69S)9,>"`"!0WU9*ABZ%&*(1O@O"WLHS[
     6MQ6G_\9NOG9C[*EO$E#VE.K[@GU,I^C%#&3*_0T+]S<<7K][<JLA,@ZI`\#-S
     7M37`'=L*QF-?NP=6""W74=[+O5-_IOLM'+/K._+4^+6P_J]WN`40ITUA35<,[
     8MXG6.[9P6Y;-I[9B9:I`9UY%9`3``"U@Q4)&&&0"'"><("9DE(:W&/0EK4@(4
     9M0`-6:0@J:=,0):6)"=Q0X%.@4KBK<%CAL#)I6,0]?J?H6DQ\;_?','HGO+_A
     10MXV0L@$N1S0`$D(`\#55">R;^V0;W?2253`JI4`IE$`9=D,6J.L55-!?13*K5
     11M9"W/L9YT^.D29'645_PAZIT+FS:L![]OAS_UY%[!6JB`Z6(P#;\&!@T,&CT)
     12M4QW_9;4@M#:Y\O2C2WZ$:WLNMSUL^MJ>"VX/OJQP+#4^?6-X;=D%MTS%;F%0
     13>:0PJC=&68[3EZ&".AN9J.M__-:U_`?FVX\$_"0``
    1414`
    1515end
  • Tst/Manual/Tracing_of_procedures.stat

    r93c5cf r906feb  
    1 1 >> tst_memory_0 :: 1361208655:3.1.3.sw $Id$:spielwiese:version:mandelbrot:99504
    2 1 >> tst_memory_1 :: 1361208655:3.1.3.sw $Id$:spielwiese:version:mandelbrot:2215936
    3 1 >> tst_memory_2 :: 1361208655:3.1.3.sw $Id$:spielwiese:version:mandelbrot:2215936
    4 1 >> tst_timer_1 :: 1361208655:3.1.3.sw $Id$:spielwiese:version:mandelbrot:0
     11 >> tst_memory_0 :: 1381309608:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:170992
     21 >> tst_memory_1 :: 1381309608:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:2239304
     31 >> tst_memory_2 :: 1381309608:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:2280276
     41 >> tst_timer_1 :: 1381309608:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:3
  • Tst/Manual/divideUnits.res.gz.uu

    r93c5cf r906feb  
    11begin 644 divideUnits.res.gz
    2 M'XL(""W%?U$``V1I=FED955N:71S+G)E<P"%5-MJXS`0??=7#&5AI42YR.G>
    3 M"/'#DI>"LY3-]BFDBUHKKA;+#I:RZ>=W)-ER6UKJ@#.V9LZ<.4?R]L_ZZA<`
    4 M\`SRJY]P88V=5NKN8@D8_56ULH0N$_</60:%^J\*>8-/9EK+\]1889-M!Y%V
    5 M$/_$?7-GFCK@Q.5%!JVJ2_B](G.FV8;EG.4ITYSIE)64P9I!=5S";`;VW,!1
    6 MUL6I$B`?A3Y6,L)<9J"%;=4C7.\6^]WE?J7Y*.>C]2UBI:,\]1'9C#4?ZY3Z
    7 MIPEGL?[+%'S!K4^<A.*2(:4(,\=?S/^*^0ZVS_<MRF>MYL.(WS*HE+%@5D8K
    8 M^T"N&:=+<!.UTI[:VH`("6=<A07(&@>1)M9_S^"(&EEB=NF>>BD$:B[*IA85
    9 M')I6,[BO&B/!-F`?)&Q=&[^0$"2/C)!7B30]WQ!3G`:Q_0WO20C>O$C>9W^0
    10 MZ)=(`(=(_\=`GW?T;]!3>;!@6U$;QU-8U=2=@UT'XFG3F9M`<QJZ.LO(Q/$A
    11 M&YQK['+XD,,9=-7\95W'#R(K/N],L;!ZOG^)H=$XSGOF-@K_4EYH#OY-O_42
    12 M[G>)5XGW@0^'QND`&N7XS$`WA3HH67P@C)_+F<B#H<%='AR=A*G?\3M!\?P!
    13 MH&]ITVF6OGX9K]@]MGOM_KO[PI?W\^.!=]\0]XTX&8(GX5/R!&>D$#!N!```
     2M'XL("%\<55(``V1I=FED955N:71S+G)E<P"%5-M.XS`0?<]7C!#2VJU[<<K>
     3M5#4/J[X@A17:+D]508:XP:LXJ6)WR^<SMA,'!(A42B?VS/&9<R;9_%U?_@8`
     4MGD%^^0O.K+'32MV?+0&C.U4K2^@R<?^095"H_ZJ0-_ADIK4\38T5-MET$&D'
     5M\4\\-/>FJ0-.W%YDT*JZA#\K,F>:7;&<LSQEFC.=LI(R6#.H#DN8S<">&CC(
     6MNCA6`N23T(=*1IB+#+2PK7J"Z^UBM[W8K30?Y7RTOD6L=)2G/B)78\W'.J7^
     7M:<)9K/\Z!5]PZQ,GH;AD2"G"S/$7\[]AOH/M\_T1Y8NCYD.+WS.HE+%@5D8K
     8M^TBN&:=+<!VUTA[;VH`("2?<A07(&AN1)M;_R."`&EEBMNF.>BD$:B[*IA85
     9M[)M6,WBH&B/!-F`?)6S<,7XC(4@>&2&O$FEZOB&FV`UB^QO>DQ"\>Y&\S_XD
     10MT6^1``Z1_L^!/N_HWZ"G<F_!MJ(VCJ>PJJD[![L3R,3SIC/7@N;4+Z)C;IVB
     11MD]C6V&7P(8/W[/BKHIY=I,3GG2,65B^'EQ@:7>.\IVVCZJ^UA6;O5_JY2[@?
     12M$2\1[P,?#@>G`VC4X@L#W11JKV3QB2H3WY>SD`<[@[<\^!F:_L#L!(?=3S]]
     13M3YI>L_3-:G>YTWM1`^`;[S^<"E?>]X]ON_N`N`_$T1!\#<Z39QC8,4=K!```
    1414`
    1515end
  • Tst/Manual/divideUnits.stat

    r93c5cf r906feb  
    1 1 >> tst_memory_0 :: 1367328045:3.1.3.sw $Id$:spielwiese:version:mamawutz:237028
    2 1 >> tst_memory_1 :: 1367328045:3.1.3.sw $Id$:spielwiese:version:mamawutz:2236416
    3 1 >> tst_memory_2 :: 1367328045:3.1.3.sw $Id$:spielwiese:version:mamawutz:2236416
    4 1 >> tst_timer_1 :: 1367328045:3.1.3.sw $Id$:spielwiese:version:mamawutz:25
     11 >> tst_memory_0 :: 1381309535:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:326388
     21 >> tst_memory_1 :: 1381309535:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:2247156
     31 >> tst_memory_2 :: 1381309535:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:2297688
     41 >> tst_timer_1 :: 1381309535:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:18
  • Tst/Old/longalg.res.gz.uu

    r93c5cf r906feb  
    1 begin 664 longalg.res.gz
    2 M'XL(".9/15(``VQO;F=A;&<N<F5S`-U:W7/;N!%_]U_!N>F#+(H1L`!!P!ZE
     1begin 644 longalg.res.gz
     2M'XL("',<55(``VQO;F=A;&<N<F5S`-U:W7/;N!%_]U_!N>F#+(H1L`!!P!ZE
    33M,VU?;J;3E^M;)^E1MB3+4FR?Y,16_OKN`B#`#]!Q+TDG/<V8`!?+!?;CMPN"
    44M_N6??_OY'UF6\;?987NWR0Z+B0#&Q*P^GSW/KA\NSW[Q'/`V>[C?G[+UHHY$
     
    3434MX*1#!^&ZA7#3(%RT7KR3*!>A@NV^#LMT4N<%>2SO6EBF<[O=Y=GN>Y7"W7]5
    3535M"G<$48]/-^ZARABG<,`F8I1HI2-B9L:5V!S0X2S=L\R/,`_>W?<LE+L19.Y2
    36 MA7+W?0OE[EL7RAV!*2");!ULKIW)`Z3LJ**&X22V@88ILC!*4&&,63&LI6_?
    37 M]6VJG[I)+_:FBSTZA0Y]V6!/?A%[Y5B%%:$P[K\2E540Y%&Y;Z,2<\;^\FQ/
    38 MJ'1X=$["%.S,HX*;&B`&-V%-K?!=`OEM@S6,&GOC\<8E`+/UBEJ,3]O:6P?:
    39 M/8'6U]:6$%]>"U&6)94,:L`U]NHTM\^_&L86MKD=*%X&[9Y`ZZ*R9PP/U`Y.
    40 M@SELC1TW"+%_P1X(T_T(IO>$Z5`(G%WRMEUR9Q<K`I'>!#YF=REH1MMBZ(-!
    41 M7KJV0K]C>5]U<;]H[.8$7$FNF*(M"E[;!0FH'$-1EH*%VJNXI&V&;7#Y()7=
    42 M:6#CZN^>4D63*'S$*E?/+*PH6^"*K9=8DRJ<@YQ+64RF-D%RGS+VKT\9PH[F
    43 MYG^<)$Q,$I+YU^`CGQUA=A2S8SPOH4\MH0\^FQRZ+[2=/$)?(YH\(CMY1#:'
    44 M6VNVL"4FCC1'=!NVH'P=!YIO8C=6EFBJ162('_C6;'H3Z3H<I&TZ]'`,P1?K
    45 M^2;0PX>+#5]LYNM(]R?X!>W!#-4@/L<-KYC'@XC2'XD3VG(;G^U!.J6@4WE\
    46 M`L':'D%K;&BDT'-.J<4VX!I[C:QH'A(P=1*F[I%I_5XT'?`=]UP\CN3T(>1N
    47 M];3?WJTNS\X"M8I.+9M3B@.,.S5^[^B[3K$1URG^!=<I2+N.OH:D7*=DVG6J
    48 M3+M.^2->W-RKW.!V0^%^@]RH[-MKL*[RGU@U;:QLQ'I'YM!BTHT?*>7.(="-
    49 M\R+,W4A#IR\JF_F$36OT1I9E?\ZNMY_>9,M3QMSMZG"X/V3W5U<?#X?5=;:]
    50 MR_!VN5K?'U:9DT$^(T$7V:^-I%^#>)YR:]5ZKZZ:]^K#<-?=<6TUBLIJ#)75
    51 MEU!9C:"R&D%E-8)*/8)*S5_G6@VO<*UN(-I-[&'8X[3@3*EJ;FM[&"M3;J!O
    52 M"Z%?-6X8;L`Z;J"/#>FTJ4>Q9\:P9[Z$/3."/3."/3."/3."/:-Z:1.+EWV%
    53 M;%O65-W$F6.:,3H.ZQ?]8CSR)H`[7E*0&G"-O3:<0$?^7L@TE&W[&*70W'?`
    54 M=]RS,84"2V$-6,0:,-&<(_/9`68',3N$`@ITRA[ZI8^&)YMKMQ@)'V>?VG$`
    55 M+/X7R&1;\+DX?\]9'&V.WI]X(P!#J2N@%4C;UE<H:)W`)R330?R'^B'[;?$$
    56 M,Y09!V(L_3;9G$<Z&N!F<3.=\!;-?]."$K`0&:7%-C>FXC`O#9,F>(0.Y6]>
    57 MPX?A==/^\`U<Q4"<J&VNNTJ$O`,T6O1&*:!@2C'%6>(7^$S*X72Z'OK<._PI
    58 J8`[H4//O/_\E^^GQ^/AFOUW^=(F=?Q\?Z\>/1[+1G\[^`Y:3!(9.*```
     36MA7+W?0OECD#5(,I/K5R0HH$:2%D#YBBX+AK#29>PK.WRQG3>5%9][M&U(W0%
     37M:)&DX`3M1`6,V5%%#</I;`,-4V1AE+'"&+-B6,L`_5AH4R&LW^8;KV0;C'0L
     38M'?JR`:/\(AC+L9(K0J7<?R5,JR#(PW3?ABDFD?WEV9Y@Z@#J`@%SLC./"AN<
     39M!IEA@X-%ML*7"^2W#18U:NR-!R"7`,P6,&HQ8&UK;QV*]X1B7VQ;0GR]+419
     40MEE1#J`'7V*O3W#[_:EQ;'.=VH'@9Q7M"L0O*GC$\<CO`#>:P17?<(,3^!7L@
     41M;O<C(-\3R$-E<';)VW;)G5VL"(1^$_B8[J6@&6V+H0\&>>G:"OV.Y7T9Q@VD
     42ML;L5<#6Z8HKV+'AM5RB@^@Q%60H6BK'BDO8=ML'E@U1VZX&-*\C[5^0.FS.\
     43M2UZ=,O:O3QG"CN;F?YPD3$P2DOGWXB.?'6%V%+-C/$"A;R^A#SZ;'+ION)T\
     44M0I\GFCPB.WE$-J==:[:P-2>.-&=V&[:@K!\'FH]D-U:6:,I'9(A?_-9L>A/I
     45M.IRL;3KT<"[!%^OY)M##EXP-7VSFZTCW1_H%;<H,%24^QQVPF,>3B=*?D1/:
     46M<AN?[4$ZMJ!C>GP"P=H>06ML:*30<TZIQ3;@&GN-K&@>$C!U$J;ND6G]7C0=
     47M\!WW7#R?Y/1EY&[UM-_>K2[/S@*UBDXMFV.+`XP[-7X`Z;M.L1'7*?X%URE(
     48MNXX^CZ1<IV3:=:I,NT[Y,U_<[:O<X/Y#X0:$W*CLZVRPKO+?7#7MM&S$>D?F
     49MT&+2C1\IY<XAT(WS(LS=2$.G3RR;^81-:_1&EF5_SJZWG]YDRU/&W.WJ<+@_
     50M9/=75Q\/A]5UMKW+\':Y6M\?5IF303XC01?9KXVD7X-XGG)KU7K1KIH7[<-P
     51M&]YQ;36*RFH,E=674%F-H+(:064U@DH]@DK-7^=:#:]PK6X@VDWL8=CCM.!,
     52MJ6IN:WL8*U-NH(\-H5\U;AANP#INH*\/Z;2I1[%GQK!GOH0],X(],X(],X(]
     53M,X(]HWII$XN7JHNN94W539PYIAFCX[!^T2_&(V\"N.,E!:D!U]AKPPGT#<`+
     54MF8:R;1^C%)K[#OB.>S:F4&`IK`&+6`,FFH-E/CO`["!FAU!`@8[=0[_TT?!D
     55M<^T6(^'C[%,[#H#%?PN9;`L^%^?O.8NCS5G\$V\$8"AU!;0":=OZ+`6M(_F$
     56M9#J9_U`_9+\MGF"&,N-`C*7?)IOS2$<#W"QNIA/>HOF/7%`"%B*CM-CFQE0<
     57MYJ5AT@2/T"G]S6OX,+QNVE_"@:L8B!.US757B9!W@$:+WB@%%$PIICA+_`*?
     58M23F<CMM#GWN'/P7,`9UR_OWGOV0_/1X?W^RWRY\NL?/OXV/]^/%(-OK3V7\`
     59(O.,!FE\H````
    5960`
    6061end
  • Tst/Old/longalg.stat

    r93c5cf r906feb  
    1 1 >> tst_memory_0 :: 1380274150:3.1.3.sw, 64 bit:spielwiese:x86_64-Linux:fifi.mathematik.uni-kl.de:215296
    2 1 >> tst_memory_1 :: 1380274150:3.1.3.sw, 64 bit:spielwiese:x86_64-Linux:fifi.mathematik.uni-kl.de:2289664
    3 1 >> tst_memory_2 :: 1380274150:3.1.3.sw, 64 bit:spielwiese:x86_64-Linux:fifi.mathematik.uni-kl.de:2376496
    4 1 >> tst_timer_1 :: 1380274150:3.1.3.sw, 64 bit:spielwiese:x86_64-Linux:fifi.mathematik.uni-kl.de:2
     11 >> tst_memory_0 :: 1381309555:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:183476
     21 >> tst_memory_1 :: 1381309555:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:2289664
     31 >> tst_memory_2 :: 1381309555:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:2375512
     41 >> tst_timer_1 :: 1381309555:3.1.3.sw, 32 bit:spielwiese:i686-Linux:mamawutz:5
  • Tst/Old/zahlen0.res.gz.uu

    r93c5cf r906feb  
    1 begin 664 zahlen0.res.gz
    2 M'XL("`?I,E(``WIA:&QE;C`N<F5S`.Q<VVX<.9)]]U?4SE/)6:EA!._MJ5Y@
    3 ML5A@7^;%\];P`F5)W99LRQZ5&UNEQ?[[G@A>,DM7JZUN#Q:C[F)FDDPR(G@8
    4 M&8?,].N__?M__G6Q6-"/BT^?OYQ_NEQ^OOKTY>C5B]>U@']<7)U?_K(XV:_-
    5 M:KE9O5V=K$Y79T>KT\]3)?OCXOSRR^)R[:<\]^.BG_OCQ?GIV>;#XGS=\\+Q
    6 M8O-?E\/;U5ND)ZL3I*>K4Z1GJ\WP=C@9SJ:V(MI?;[^<+L\AV4_.9/\#OZ&E
    7 M.]KZI3W:+OEHN]V&;=RFK5ZC("\]3@)^$;^$7SX:MV2V2S*X()*$);%'H_P1
    8 MC:V>UM$\'EL;<F5':1HG;AQ?P$ZGOYY\69Q<G7\YNX+E?@AF<?)N<WXYRZ*<
    9 MNQ+IQ\7?U91_7Y]/JN4?%Y\_?=@O/O/Z]&S8O.TE9%J)79]HT<E41JW,K=^6
    10 MPE)#D].I'K=Z?EV,.BNSTP"1.UY\A#H?SA8?J0\18=@^\\M?SBYAX%7/#3V7
    11 MCH;/]E9Y1+GMY>Y6>4*YZ^7^5GE&N:_E75HV':!79Z>O_VU6,D$7F7_^<SG?
    12 M_K`0("^TLJ1_VYQ_T..[JT^__O).\/KZR]7FR]DO>\D^^_G\\FSQZW;SRYG<
    13 M^/'SE]X^;%AM<Z$8_$@=A+:`D)><`"Z[=((J9X^`CW$+;'J!FA=$>D'?,N`Z
    14 M+(-D!(65D=PH,(P>P,)!T!JU<B)-`<^H`)52P6<,>I,_*M5;?EHF;2VQIDY0
    15 MG_14:Z:H:9;ZM;4D?64C<R5;*<W:<HXZ`<H,F/VUEM!9E49F2A+ADVB$4LRO
    16 MUJD[:G>,DRYB#M&PJ6./,.L>_\,T/+RV>CO+#&<1@E,55F;FC;H>OX`?C/AB
    17 M^?H'RS?UNOUWQ]R^8VI[DSI&;,?@Y:>;^'2'90+$6:E_!+U/QVOH>'W_!^*U
    18 M#>_=>)5S=W03KQW@!3R"3B0*0D'1U^`525*XHJU[0.N:H%\-VE!!:Z?Y)!(W
    19 MI=S7H?91V-X'V4/,?B468Q]_/"PO7KVX^(G>K,^J&\45MRN6*_MF?3J5N7:E
    20 M9?[-^F0J"^U*R^*;]=NI++4KE+7>\91[_^K%^X/>WQ_T_G[>^SBK-!-CG-6&
    21 M/#ZPY^2-B\$3>]/D&SBQ32YQ--DBW_1FD\\F4K#D8_*)@\MVUA.4(OF+(3O*
    22 M,8?`@0([8TQ3=D2'(45`*K-E1Y%S,,R9G;5-RL%S)H;Q<[`.+9B<C`O>^&3M
    23 M3`$8C3)%&PCW)K1BF@TQTH[(16DBL_%=+TIH-X;$`':<M/(N1+8&'>047<@S
    24 ME3`6SF5H@NY-,IEL](:#3<F8MUTGS^R3239G%ZSUUJ%]YIG6Q#;D['T@:PE%
    25 M$78-%HI[U.YZHY9+!,,X=IY@1!@@<S*>HY\T;Y#()3I\M]Z>7Y\M+R;G9_%0
    26 M?_?J17>C%H]RK?/^:)[+Y?[M=!_<[<^?KI;;-;W:_F7][M5VO1VH=V@1S?Q/
    27 MOT`0LUC\]3^6[W_:OEG-.T><\K\OKEZ8!W^M<GJXQSSKT9G:XX7T^'[JT?$3
    28 M>G30\?WYAP\(O%?O5MO5Y=3,++)VT$YCRBVMEV:U.5HM=ZO]ZGKUWP<!NL,S
    29 MH0;@9KW<\$A'+W<\7I,9KUG"^D$R]K;D6+/:A[%G_K<S4T/QN1]7+G71%NN%
    30 MQOA&GE?!`W&(\ME(=&_-UN%_VCK>.K?UA##?\Y@D/D=Q<GBL)3]N,UQN]D`Q
    31 MS@DSTOJ['&B^[4!MER?/`\W#A[4WCVG_6X-,3]T*]`QF`/=)8?QV8WB9>J]>
    32 MG(LWKWC@?1B6X\8/&S?PQHX,-)42Y%M<6)S:O44E%*,*XS<R,E%?X*0%@V0P
    33 M&N8W$QX!/E21%!V,!7QRRJ5CU,:#@U_NK5:IK1Y4AP@;/VY<[[KD>]2`:(-5
    34 M^2T:<EV?/?$]^OC]3"/>Y]L:6=2`/'E2:1_0.!Y8F%5#E6R2/DR=RJ0:M7*4
    35 MS#MD#J@Q$]OJ+:)U$;'VYZ0=K@UVF[#D[O89S2>U6"Z-=2'E<D]BEJZURN5$
    36 M%[M1C8MA1"!76]4&,YXS,D;:HIJBP:+TL0F#A3*VZEUR+5132V[&N3)CE7>Z
    37 MY*'+#[$#^NE0E#4&`A;I=P,C/0V-]&QPI-MXS+!7&A.L&:!>0!M);:@-8)#"
    38 M)F!BH_4@JCOH'D1P*!-$>XA:@4EV$P>;I;J5ZA[UD=B!U#X9O8H<<0`9D%Y$
    39 M5"2C*W@0E=-F2%6=$5WY(3)J.@@D"<LE\HMBC(S1!]@T%>WD'FDSB'Q!"G3F
    40 MB-+WS!.Z<Z)0F2D!EG.*I0E=*DV%CJLYW"?"-!Q9[5XL*A@E+K!$A@(%^F7H
    41 ME'$SS)(+=!2'N%'L+#=T&SL9A#$T7`11@$N&*H&9MRS8JM-/-:JS[L'A3=)@
    42 MV.!1#&MGQ(*;-,#0<4P.-R"IQB<Q/JIHGZH<8:RS%2,1QIJ\#+:D:)I$*[O!
    43 M2<5'&U<QBQ=I&.+'0=*@J1^]-8(NM9.DK'4&7P&##C*D=S'*A"<1R:I,DB.%
    44 M#4&'H!!S9B="QJ"W&U$(*68$<L9<H322<2JY="SI@(P&JB2#;EFLYK)68%&G
    45 M8PMN:NDV`^HW7P6%AH(46]"RF0%F5)?:80*;ECN'FXCS:CF=4S`3U`=4''X6
    46 MYSS8&9!<&9_</5!I5,$DDPC#.(C)Q#9%4H%40V[%%.9-P6>!5?.%[B"B/I]%
    47 M*%XCZK[HZ$.-J,]E$6#*CC=#:O]P@.OG`6YH`2[LC`AWUGWXJ@AW%N6&AR/Y
    48 M,(_D0XODS[77V>)@^*I0?MYMJL'UEB2XGAK*4V@=H64_IQ9F\T-A=I2EPO-+
    49 M67%=)YEZ4XEM\=W%MP7@\<'5I/CLJTDQW`S/+[YK>![C_>%Y3+]7>![SK?#\
    50 M6\SP7.%Y,E-X'KF&0^3$PTDZI!H),<&#(.FN2$KA`5/:R&GQ/!!$O"FILY94
    51 M3ILG8B^^2%+6\X%H%L'G&BZA#8U"0O6=TI[XP!9`X-G:XW@*+7(2X52VT@1D
    52 MZM$&2:_2YH`'2JR/!5;9W3R6%^4U<+JIO,;P,_5+&']+?5MZN],`);R_6__'
    53 MPOW<8]OJZ8>B78O\(^<ITG?21SF@?R_!A*3S>)DXES`OARG6R:+SH`<\*IS9
    54 M2#)%U6R-%)`QJ4=$Y*(\T_6`IQ;C'B3Z\"N<04:GD@82;4.G#:F$,#(R6I0;
    55 M;9!`1$>E1+`Z:I;KT';N8+D_D,4<TD*:TP>6>,Q/H9VJYL3JK?G)&`TWLPPN
    56 MHBJ!$!WF#"+1G$%\K_E"OV7"T+/.&*4;/H;.\7Q6\F3T/KT"63"^,HVL\9\>
    57 M(*I)!FAQT7./(\GH,.F!RY5>E+ECDT1U"-!LR&((V#65^)%M4!A%DPJ/T..H
    58 MV1/YH*R4A#3*T\-@?7)58>]E2F!N5?R7:XR'T2DBVOMH=8:4(X(M$0$&SL%T
    59 MBI(-J98Q.DP@X45.M7`Z:1YE*P_-<[HYT>^<Q$^;I.(N4E+*(`<N5P-%4Q%,
    60 MQ@:E"'I$1.XMK")IP_3D+TI,2C8IC<S9:LAI="A(;21H3\GJ.,@!PF<11]*&
    61 M>(HA%!0`&BJ1>*)$<SY$Y-MBA,"O<*$'T)=*L%T<(\>@*&%KA9]F#%4!:%9?
    62 M"6P8ZR6HQUB&CLW[X5.>!#ZX,E6SK9JED)/$XX!'Q:D-`>"%"-YEK^-4<]`E
    63 MV0FJ#P--T>I(\"4MZ0FT"39[X<_&FL9['(R0E/H$R&"*4#*.(-$^=,P&67L7
    64 MY9SUT$@?&BP*CC;$,M"5"<%Q=:\[BA<3JCJ!;Q0"'[DB2]L<U:2#/H28&Q=2
    65 M/RB(5.2`[`3;*5$*Q57KPD84[+A*A8*251T\38&YU+@U!%.[1#4O4D"\^E?I
    66 MI7K;0I]D>`;I1D[G="CQ?70HV4,ZE-R=="CYFW0HA0=Y28HS7I+2?70HFR?R
    67 MDDP/=IMYUFVV]]&A[)_:;6ATB`_H4(X3'<IIHD,Y-SIDUTOX)&/OHT1P:"UR
    68 M?O]-Q(<,/4!\\+1Y9N(#QWF3^+S_GL2'C+N7^)!YE/;]1N)#)MPB/M]BAF<B
    69 M/GC&_,/M2]30K)37*,T8DMC9F+8:/)8\7S(W;H0D&O\=U/3E7E-+S)SI_'/7
    70 MXK?N6G3:(;;N-D_%Y)U_:&F0@RQ]ZH%;I:F*/,*G,J/-F)F^-X=^GEN[;F&>
    71 M7AP0%838_Y!;'7\`PO^Y$?+_=".D['WT%04!0YL&=3E!LG)!`\;;Z39BD4[I
    72 MN>9W_"@QL+)#@I[RD#=)ACXB<L9]3LQ0N$P5Q1:H$,+J@%HX>H^*Y=K+D653
    73 MI1SM6/)Y*/7*92<49:F^DH<</83%4Q+0DC1HZD=6=,FYU92U3KFA8$SZ8MVC
    74 MB<&6ODO/&L9+GHK%#7ND:R#"\1KS=5&@C&#>@Q)Y41DIA)9%"M>8OU<&65>4
    75 M@#G/#8P*<JI!>UF$$-5H1AO*J'7B4&?V.,WLL<_L[M/<S(UR=0)C]9]B-$5@
    76 M6>M03UO\IZO>M-542J%9L91H/9FV>G#E8$LFCP<^..B=5G>^<H[%14_.406X
    77 MUY>ZKB?/O'?S5@V'/,>CF5$1,OD>*D)D#J@($=U%18ANONQ$].`6"=%LBX3(
    78 MWT-%B)ZX14+TX(80T6Q#B-C<0T6(G[@A1-Q>>]K:.14AGEYZ0MQX/)V'1D7<
    79 M8U1$7HR\<W>&N+^#].';2`KGATB*??3UH:>&YY9NDI0/WY6D6+Z?I%C[>Y$4
    80 MZVZ1E&\QPW.1%.LGDE+"M^)K9'&R>:KIA9C#J!5^*,)ER.*H'!!:R$$OFD=R
    81 MS.J1]`AOI4>]G'&8NLP\:Z0MY5@O[P64`Y>#I@7H3V,U&N,-Q==_!8<IH=T-
    82 M8U3><D!;NCET?^9^@TCU1^SQ&,7IFPC%+L/<+D.Q2R,^?1W7&F>E1SWB,</9
    83 M;S2=,8$#R]>G([QBULB`RTIP-$$6ZY%.7`%V";H2#0B;'L`%DF!ST(.$-B[H
    84 MMH/3%?7&G%J851U4*'LARC(DU)+']EB'Q)4XYO!A5@-OY0_T=`9ER],S_[&<
    85 MR88Y9_H>TXV^=;X]@60]8<+1-.-*/&0U+M)-*[T&[7$YUPA9PT4Q3,S@/C)$
    86 MN46^#T\_)QC6D-D)-Z.<3"=30A7T?4"D<SH5@7'9<Y$#ERMIM[\C%.J^',"D
    87 M^W%52T<E2M>CC`3)`CI&PDQ,BYQ-1I>JK5=5'<O*OPQ77QA_B'5]I3N@F3^X
    88 M:Z;_IEFL.VHAVL(=HBWL(0HCP*$BN=BN&$T[33H:J:%[[EMJO(M2JZS(E?TG
    89 MBC+XE'S;XG$IB:YZ*#M]^LX5#HW;Y1A-(11)1]O8#((8*'?;-?\S]S@M6H\Y
    90 MYQJ.;_!\52Y2MWADILI@1L^`M/>F`K+L?^!.*QRCL*?"PZP/^E:I'+A<R<#D
    91 MMF%/MI`OW8,%QI,R?&-T0T$V=?1]-7E3C0<Y'WRV'9JP&NO&9-"Y8.2UM%C>
    92 M/BO4R^B]III15@F,VA[:ANCDWA"S[I)DK_/$3/LVSF1=PLA6.)T-LG-G?=G;
    93 MKLRK<ZXZRV\0JSFA*A/2E@G)Y4HN&LTJ[L..W9':XD[LC&FI_7-U'DZ=<SXD
    94 M4W:<J);=S!C5>(>CG4C4'1Q*7I*[S9MLO(\WR9<7<]YD\YV\R9F;O,D]N)="
    95 M;K:7`B]Q'V]R3]Q+(??@SA&Y..\VW<>;_!-WCD@^("B\R1WP)GF#OY]#2['1
    96 MQ^EC$I)7"94_74GH#*YS#>:T`V^:->'K1\1;6C,`,T0`V0T6Z;6=:H56B]>$
    97 M(K[&2%^GJ3RV<KMVN[T?6"MABM*.)@;EI\]!UEM:;7FUG?7Q(+T*#]*KKV83
    98 MH7.JB^F3<\S]Y*-PB:!<89OE4W*B[9;LEIQ\=$Y>2BB`15`$9TC'PB0HC\?X
    99 M@S\J+(,9=4>6):+QF.,=E,+?HA2N3Y.`T7QW_N'M\F(E8*&5Z?^-5@^\HM7(
    100 MJY%6\I_D2#JV4SGIC=E[/JFFX![_I/KK[>F[/>D/,.CR]0_P?8]\S?N@C4.S
    101 M,3V'D>]_7Y%"Q_H%/Y-EBEGL$?/QN"U6@5%@KF-.QYR/K3FV=&SYV-ICZY[!
    102 M6+D9BY_!6-%,SDI>N;V\^<4@R1NVE[]^?'MVM=C1:L=305TE^PBW^_$OZ\M7
    103 M']<?9VXWSE?)(GSZCM8?SC:G)Y_.?L9`__3QS:P/N.@=SXKYL#C#B_Z\W-'B
    104 M7]:HU[M(-.LBP=7^Z5_E[T_]QH1NM:WUCE[JR52$+E4*$(B7>C(597D2U(M,
    105 MM=YX>+^\"Z`?''Y\L[J8/4;D30#))RV8Y>MJH,KW8O1A[W?"&O;P[D/DZXPI
    106 MOWCY$CTMSK>+RT^+[9?-Y>GFZG3Q=K,]W_9'CWGF>D6>F!SDL0.S@T!AE'>B
    107 MKO/N.\GTO>K5L;'9(Y#=QYUL=1"G'/9N1_(VC9=7OO9X>"8A%Y2-VZ<=$4A=
    108 M,MZ)"4EV%8SG!#-2_%WE"SOR33Z[HS3)9T3:)B#4"%U`Z)&;@#OFK^RW`1BN
    109 M\P*S'],`=-\EJ#L*<A'70EDC^6#C]MJBZ2&B+QYXO_.2;X7VP20:GDB&D\^S
    110 M)<?+2TS21D'<2,F)2:6.E\:(AG@MA(6O$T)U9,MWY"Q9")OEL!MQV,'N=,WU
    111 M3OGX&\TEA-(>'!2U(L)?AXY8K"/Q3PP&%Q$U&&0`IP[4!R+A;`?>SCE*:QAT
    112 MN#&Y?Z>OWZ72`#JSD4L#<;08#6U`/AYBIRVHI$FML1,5]GI`BTX*LKQ86GN"
    113 M)-)!&KQ3.8`NX2G:NBB`X<69AW0J/LL].9=.1C8^R<V[,0?CRMVRC6I9[XZR
    114 M/\5Z>Y>-JW!DWJSU]3XTY`<+L"`\=WMRTGV_(DA`\H);#-*-F,AZ&XRTR*!O
    115 M">119P=,:KR.*%K#@\1$D3",-D6V%G!#PZZ!TDC#$"XYEV,622%>L"R?WTO+
    116 M\BI<,%F<(X5A/N]`@ZV\T6ATX@W.1H>!T(DWS";>`%YIBS0*-U+`7FL1IT1B
    117 M$[+PO!;PJ(.:9%5#2Z*.58.%M%QQ$1LNDKQ92ZZT$D#BC8X76LDCR^NLI159
    118 M"O`5&Q[LM+12).)J_AV;0?YY`)<A+P7(E-!)\K`QVDZ#BPY1(W24:4V8:U[>
    119 M`S;2O.NCX42V.AKB"]IH2.-E,'8(4D*,P2<9UB`^'E%WR!F>'_WD,26/*"@X
    120 M[0<4&2R=<A#DJ^C1QM)/:F.#%H<#ES/,7<XP=SG#Y'+:R.RXK]GG?.\_Y,+&
    121 M/,`^V#0"=D53WD2^V-BZ477E%C?_):WM=`<B[\MUF*YGW*O^`T[#V68J_K_V
    122 MSJU7KBS+RN_U*THM'M)$A;7N%PKW`P\(),0+SPDJ'[NE1IT-ZE-(Z<.?9WQC
    123 MQ8F]=OC8,M4E@2#KXDS'9<?>:\WKF&/.M25=GSY?XM.G2_SX=(E_TK\?HZ12
    124 MV'(OID7I,_K@GS[Y4_[CZ?CL>/WL;;14_-/Z\^/Z\VG]^>GXPNL$J^?Z@3?N
    125 M8[M2#%_G<G]0?OI<F?G%Q"_F??WA\W_^Q^,K;R5?MWE?R=.Y^KOG[)E<Y;GR
    126 M%\_K:@SL>N^I7N\]UNO]\[_[*;9W[U__HQ?KNW[[M^[7G4;P,<:QQ/GN]KD4
    127 M]V^ES`53]9_CW?OQ_O^J_URO;[[,4Y5W/Z5M`?Z/_(?[R.^\<'_U2_^4PW>N
    128 MJK?3VV_KG?+M+W+'Z5UG^<YOW#;^6._G;CD[?837XKO32]]/K5K_NGXXXET9
    129 MOEU-33&_E57_,S7E54N6CBS=^"ERK<1HI\2GQT]I7YMGI.QY>J#4-U<469P_
    130 M(`-+7H;U[:VW3Y*DO_5_GEQ]+4///W:?ITN\+6=ZX^N'^+[L??=7_M)'??ZI
    131 MO*DGNN2//:DN\"U->M65;U[H^]82;7G+,HS;>V\\\NL%K[S_U?H>/_=\TN`K
    132 M_[V.ZUT9%>&]H8PQQ*^T,:=VU[CR#;@LQ?H6CO.;+O[O_.<W7?RQ"_P_J8L_
    133 M_:=_E>IWQC+^!<K:CL@;ZMM72&*"W_86DJ@$\WM(8H+K]C_O?XG?0Q)3RM]#
    134 M$E,R#ODO>?OVUO77=/OKPX4>(<GSNW.[SO<ND^,&$Z;M]1M\F,XP8<HN?@$*
    135 MV?S8>M@L6-K^Z3NO__:=W[[SVW=^^\YOWSE>?S6J;8>N;Z#.]>/GZ]/GZZ?/
    136 MEX^?T^5)___T.>G%K%>S7LYZO>CUHM>+7J]ZO>KU>D.Z/Z;+QT_7IT_ZF#YU
    137 M_:C_/WWB>ND&>7]\TN7T_E/2QY)^1C\%KO,IZ=/Z*7[R(W_H37V27]=;>DT_
    138 MK5O0SV:NFOERYMN9K^HUW8YN2[]4^'[A^X7O%[ZOUSY7?;_J^Y57ZPUP;T_Y
    139 MT[7I9I+^S)^O;4%-2:]\OK2/^NJE?=+KO/*9I@;NZ-*>/ODOW)G>8GGT`?VI
    140 M;_#A\<0_VJ?B2V5]*'-!?W9]1Y_@GZGH@^F2.H]TR8V'THM^+'V3A\V9Y[ND
    141 MR,*GR*/%Q%/J&HD/Z!U_(N<GKT36)?.U5%9!_V`=>!+^HE_U15@1OJ>UX(K\
    142 MJ26Y=#Y6+SD^\8_"X]5;T4$WKJM?_(_7];D]C6\T\;>U4.R>W_(_GM8_O(=>
    143 MJ<MMI;P@E]N"W*[!/UD0MD&?;'Z>QM8V'F8]=UZ/O;[IA;_]D^>^9&^^G]?;
    144 MI,][_S,"D)&`QL,-/RGK4:_M]3G;SQ^*+J[%\S86[=\UK8U;^[1NJUCTAG<G
    145 M^;<3MYB>CILK:TO*NK7B'5G[8;%,W@[?GJ7S59$NZ;BWXDVXWQOE&^XEK677
    146 M[4E:UH)O8A;36<YR6_)5WI"O5)9\>96]-\5[(P'IZRER6(]1;\_1_!PU^DGJ
    147 M>I0E6?TD6;'R/+$B6=&/%$/Q0]7@I^IWT1HWT;)2W21BJ8;7>LG1VF3?`+>#
    148 M0%PL$+?5_GK/I^^#/;^RYU?V_.I;N);SGL^?/SRUU]K/QT_:!OV_?JK:_J&%
    149 MA4U]4[.P-O6:VFTUVA*XL)8C6=%B&KX-+VZ!TNH[&8E;T:78XW4?:0E?*J]W
    150 M0CWF4WNM@^2/;&O6C5QBY4:NMUVY]+IV93XMP["D:WH-L`E(V2Y@I5H!9&/X
    151 M\>Y-68J>SB(699YE0R3TV4\^;P]^>^Z\"<%2,Y38S^Q'COX=W8A^8#[=Y=@_
    152 MXLO;W/(DS9=?F[>,+/9@N[KMH:7Q;KRTSH<VGR2LK/7,_B')[/UQEMFR`EA)
    153 MTG4]D:VX!6FMX!+KFQ!Y_6SF7]=O/=>%Y[KXN98HQ_"P>K8>_K7;NMW$Y;9-
    154 MAPU83[6V*&T/]6H$RK8YZ7YY&8"G?%QV+9=7Z_!T3U^YN_OB2]$^+^&2Q$NJ
    155 M[(^39%X+X]IGBNQ^^K2NA1[<G/H2QM=;WC8T+7EY-6CU>KRCK<8-E5WG_$8E
    156 M`M!%?"4_X>L#)@:\)W;P_O/7]?2O\<HQ!"+E\?Y6Y"I'DGC,S$N,OOYVB0Q&
    157 MYBJ!?;B_E-Y#.G2[UKL__,-1"&/\M:M*?_?AUWKY$N,%MNNO67^\M.N+R8/'
    158 MAX\&H`__]4]/_^WC3W^W_6K]#I\O_KRH5+"KTG.L4*GB-"2SCI%1N@^W2HG^
    159 M,Z\VD+K^+J4K?^>5H<_DUS-CCG-E[N@'(>`SP>#S0DFDUWL9P9]X?7.K+AR?
    160 MN5+D2?5K1.^ZOKP@)?_RE<LW_O(6#'3`*>`M\1MXRUM8R]<,L)3O\2R$UV]5
    161 M*1@7_FWNWS<6_ZVUOQW"\_[ZG!)K[F=_>^&]XE^O[?M4MB5\?C;0NL#5Z^,R
    162 M\><;*WY]?P)K5_6-]3[VX7J^T%]QO>]5(0:F?PUG,;;\33B+F>7?@;/JQEI+
    163 M-7T7SJKE>RA4;3^(0M7QBBK]Z']?O_B=XGP[J(.IO4[K?.0T__?CXVEOG,28
    164 M7%_*'R`M7W\]3!L,V;]_2VX+ITV-M[;NJYV[WSVDVG7^T_-Q_E-J;Y&K\_'V
    165 M(ZOZDE_Z\>Y;G.J7[=M;+?_7=OG29#N/-^?]G)A?PMT@,_7T.;X>0_%\/[WI
    166 M^?4<J,OS.MLIWT]L2E`UG^\G0MV^S7=>SX:ZWJZ3C_WJZ7MD"MB<QWE4/L2&
    167 MAL[V:AFZ#_?J'")S&(#;85[/\Z[T5G+K^/,JG41]FN->5@D%BY%\?%C1+;K,
    168 MKW]<5QF%BL;U=BK8.K'%Y]+X,U=:0OG6ZT>Y=N::V8?%9!\<D\L[GQB6^8E<
    169 M*?ID[B3[:)W"QU_/W]$?7*QPL<)G"H]5HX^C*?Y\#>M0&OX6"[=;X_VP'NZO
    170 M]G5LCVPE;S268YW<HTMSEL_W$/:K#YTY;O!T:S[UJ>1U,V_;L=BNKDEY+9\?
    171 MW^S?LW9?GV;3XKP+PC>+;MNHVZ_%YS@"Z9?TH^(3?TQ\+#N(4'RW/?$F(MH:
    172 MRU!?)\A9?HI%)[,/-]DYOO@-`;+(>,<SG\U\-NOZ2Z1N?],??'/)4MHV[%66
    173 MQDUH;G]YOIWPY!^I>=]*9&K_^BZ%_@825^["Q@7K^+9$+6EZ^S9?Q6BIPE\N
    174 M2W_-T[Q:.F2..0'QC[_[Q:VDT$9?31_4R;L=A$+Z>OS.+V[^Y"B?"`NPCQ&G
    175 M4M*08\NS]TK_FFPYQ^J$6GJF&[&7,4-KL_7.2,P^9]5+><S(P3HI<'3/T,7X
    176 M3DRU^JH]R'6UJ=]^/4'OVGHK05<>N>8\=.U:<V\SSIGDDS,S(?E.#K75,CO,
    177 M/-X()?2B9Y4'FC/F`*]RZHYS'U$W-6BK#/K-/.-HC!\LQT(PHK.7./4$^K>A
    178 M>PLS,ULQSI[&[#',6@HDU0:GLGB0"N3@R&C#V4/)839.&=+S:6GB2+GJ"J/,
    179 MRBV5W&,M(6F-MA6_,O@QI#X*LR:G;@$FZ"BZ8M-BQSJJ%BWFJ)]B=3NC+-F%
    180 M%'2]K&=(6N/FTYHF0R*U_J,,K4/HE76?NH>2=3,/6\OLU329^:@?##V%4*J>
    181 M<8Q<M'FQ\4+,2;LU=8.LK'8JAS2X^U<?>%$P'!*[V%ML)7-P50BS<`*4)((M
    182 M[A(21C\V?;(FO17'OM$IZJ=RZ+KK5B6O2?&([J!$I6A#:Z6+M*+?IV.38YNJ
    183 M-F_?M%Y"TSM:LY"T!TE;5U-4\I2SKJ!7JE9>LLC5.D*EC9N[Q,.'#C/DJ;M7
    184 M(-1G'=K?QN#0&GLL/)EBCEKJX(@J6B+U@AXAWX^[TLLQUBSQT'K%TO2<L2/L
    185 M$;G7'M6LQY*L%OU,:Y*9V!]V8]&UM>#:7*E7CEIH+8.D7QOI<ZF&+JY;2E';
    186 M4*4/G=9@"7_GJ0HC/Z-$)^H!))U#?T5-!X);)(?:G"+%E'AI$U-X.=V_[ED7
    187 MUK.CB3U)7*5R6NM1FK1!3U>5#VDI0[:JE@:K-='MR)V..B2#DI@F(9%4EA*"
    188 M;@?]U4+%HL65L=`-Z-^1@DU\KGK$I(>1-H>J3W:?#S81/EIXM>!:A89(6>6:
    189 MGAIR;N`$,3[&,FE]I0X-BQ"KE):G";((+-.`RJS]ZD6WLML7)J/*?O4B>1R2
    190 M#-F&(#5"9FI*T@:M&V8`DQ6E';IP*U/&:,RL/92`8=FD[P5KJ/V1FJ6I#6ZL
    191 M7_(TUU8]ZTC"L!E;W7#W^6II-JF&A*YI<ZV%TD.M19#\)/1=7Y2!*Z4PO3=Q
    192 M5ES+$F69%FY#E]`2#`C$;"[FE6/0)";KR#)$8:3=SC"#5@\2F6&<45OL\H0K
    193 MWKJN)#/.I-G!:6Y1.]VE%)*D2H^YEES++SW@W#7=<F&44TF2D2HK,4)D-"P*
    194 MH`71O^M&XB9?%SU1]]%N&%1998F43+;$17O-*%])WRP-LC07RQ)HZ9XNI!>K
    195 M'C!@V#J2+K&2HNDJDGB95-H""NJB:TIZ92\EG`]Z13O\?15T+X?Q6N\W^<):
    196 MM1>979-#D7#I2EA\K4C1ZC"'5P8YZH[T.[J[P,+(3';:FP/,<AD?V=@B)=&Z
    197 MRR'*V&B#I8%E6.89_"MK@/IJ,V7D7DX;(PGJO"$K,:7%C.,-&.Z">]%]R!!+
    198 MCEDH_9KT,M#OC_A7Q%\_*<-6)07:$ADL.3A9&/UKPOTUR8@<K-:3,_8*JZC;
    199 M/NF_IQ]+`((,5Y.1E\7-VG6M@9XK,LAWR*/K5W45O#UW,7!`[HQI>M2,NLC0
    200 M2><E%#5(CRJ?P/S:1\M!26)ECR5(6#:IW.Y$HJR)Q#`B>_:X&1.&Q&A5M1`P
    201 M[>7AT$O90KE6:0$3CAOW9>N'F^UV\EAZ*8(D:^"MN0=Y^H"1DB/A9,1J#W7R
    202 M072NR/PW`@LMI1XLVWCK>K(INN]2^)(,F:R_?K2C8TE&:!0,L>Q^EB'HN276
    203 M;<K@2B`DLO+J,EC,;HZT!2BBD)+)9FJY3S9!!D5/*2UD5AO[B^_MR&6>M`S(
    204 MF[+[\B)Z7CTMYT)*`)77*L)`)0IS([0CT6<[RN]%8BY+4)8?"80B,DY5^B-+
    205 MK2TJO[;7I]?:)D8*Z>HRO[I@\2&3$E]BJXPYT`(2%6C)9::TBP6/JU]1P*6;
    206 M#];`(&F1'ML^-0Q10%SL"Z0E>1#0=)E'APDG!RQCI,UB0+6<D'96^ATZH\\Q
    207 MPP1U6)JLGY('CW+*#CZ)-2H:(%.LY=3/2Q!E.G0+"76R#Y6($*]-CGK4E[3N
    208 MV@;>;"?_A^U5E*=O2+*U;0UC%E@'1Q9:5`[1E%[*.BA2R'+BL@L$O4EWB*EM
    209 M"$;C>,LLTZ;-+`T=L<CKEF6/,?GRH_)&6MI<'LQ4__G#E_:Z("]'J$:$]2HI
    210 MTM1?[Y_IFU'C`N-^`>4_],G=K8N[Q=ZX=+Y?+OL*\^</LMO8+GFAH6A6.B6)
    211 MDVA(D+3C#/V0499;BBB>[*^\M.)D[44M-LQRAEI9O<;$!%DP;33;TAPD!S90
    212 MJH>#'411J':G.ZC\VE^?C\!\2!H#BB)I:/R'X%CY@CQZ)<;4#^L6M+B):1@8
    213 MR(&3U/Y6CC1%\FF9T:_@'S*2H=]4UH%B*GX@]I=>.9^0_QCA98^,%0Y*PQ0`
    214 M$V7H"Q)*_5TQN"XG%=15E;"0O"!K"6-$4B1+*Z7EZ-'J,$2^"6]!<(Y#D0E*
    215 MBAR=2-%/A,F,/$K'H]1Z<@?D6(HZ!JXXD%DDXCS"B803T'JAR$SVU[](`C'9
    216 M6D@4VU&1W*+LHV26L8R9+5("I'O@F%DE(+*I6"P]1]--ZG^-L>SG@%">2OL:
    217 MB($4'!/6T=9$_"/3*^<]R$@D]E($1<R$7>QH)Y!)?%7ZUIC\SOY)!!CX+O>$
    218 MGF`']#K:(X-/P"4#+9NK[4JGM$)V3E8(%\*9!2M2X.!8F3Y=0>&$_-+`Y`2<
    219 MMI1*6ED).Z>"ID3\(ZL[B<KE^61!97OTT2"CB)"2F"34'9,E<TAFH#7=`T2M
    220 MJ61?3Z,\1F:T:=UEB74K/!:>6A=2\"5!U]UA%@HYI4R?S"^.6.&8/;GLGNY'
    221 M;Y.A3B;X:$,E7Q(',D,)-HU;DE^BNBVQN6BI\92)@P`:QH@HLY%\Z+K)D;\L
    222 M%@?A1LNEP@$23%GS0$B$-9;9DY_0YFNK(^:[$J]):13]$DIJZ_$<NJC61VET
    223 MHIUL$T7&I51LKIR+-@3O&XA+"_Y*2JD%U97U@(I]_-M$!I',01HA3\0224J:
    224 M5T3_AC%P_K."U(@V)$($@@5P`\5VNV6^%((GQM1)N#HY<B,`(++1+TBZ"EGW
    225 M8+8+*60E.U*ZJY5E44C802F6"QX1@R*CAMIAGR4Q`]\@\9).D]8H=937G8^)
    226 M,K5\:VNUB`W<N<0%F2L$(XH+(@%BP-4I1E".]>7N72_R3MIXQ$'Q*3!&9"\"
    227 M\`#`12,XXE3B.77==HI5=66I&^E)'K0!`CPD,F,Z%HG<2;8EBIWD*SU&MC``
    228 M\LMV(S\(^9@O\')XFKLSD</8G$G>OIC6%SDX4CHC.\=$*C(JC($,;W-T*YN@
    229 M<'Z2[H%($&],;'H*J*@!#22&T4TR?5H<!8&%`SP([.4OG-1I"W5!0)F5[A;T
    230 MF3"O:O,R>0QMQW>/R7D-0WDYF2)RVXC(=8O)28Y,2L!"<,(U=JP!MG"PB^+M
    231 M0C8W"`0Y4AOG)5$BLT2(\/>Z;<6![#O!8B;/]+,1"B/*"@C1+[V67C:\@O92
    232 MO0T^,GD228R>G7719I,+$E/+U%AH%>446E5MAX@@.56;F`:QUGU'@B:IOA0,
    233 M-6D8P4SX7\G-.3@#-XHZR/+)WU:PAU&_[`L42.[9,O^FC+>B4/T,UI?<'ZLB
    234 M5Z*8E766$JTKZQ/RI_@Q+;R>DWE14M``$#'X*PK/"#9%Q8&$S::"0[CC\J^-
    235 M-:R&Y,HAI5>P&\Q3`;Y#/<`8^$66=!!(HNHQ.UR6_XD<(8(?+>AOXF84@7,J
    236 M3R$$)*\G@"$YZI8R99&*8`-QOH(QHC*IF6PC"4IPZZPRO"]W\??AY`-++?M-
    237 M?@'.Z*9J?1)K(HM8,;,*F2=;*=.F^%*F=6`DM,^%($6/&0FC9,U;(,J1YD:?
    238 M@R(=EK8`==FXD2ZRV2N@#;+18=SCHRO8YG2<A6$+!&ER@B":F1YRK+N=GJQY
    239 M!#"009T,!Y/7DUF\Q6\%?%$&L1H;U`U(<W`EVCC]KAZN,N[.Z)'#:=!#K8*_
    240 MI!4HIWCI*HWL0(2D'@EI4]B/OT&&96$!%Z9ST9`PM2P201U(<.>0>ET<9$?&
    241 M5>NL0*Z2/4@A==,2.RG4D.63S!C4=!RG#=>GD&Q@2@5]K9T#J$J^TIPQ`6@F
    242 M7U2;W@@!B0_);["II..9OFMM`QB@,D4]96#8Y;AAP0@>Z@>*I64A(4SDU!,0
    243 M3O^42"$4K?BV%4T1`]1VRJ^UT"1>P>&DQ$A/+-GHF`NM'<FAED`AA'0,GR;!
    244 M(K>4Q-KX.5^6#J"8VD9IH=X'P,D\J((WI;V2<-T?02.FMX.02+I),V5-,T;E
    245 ME&[K,61F!S'%,,">`$\4[7!`%"`V)EPK2\2(DI`A@B"#\2N)[B#"BB+!?R9^
    246 M+#IW5-XT\5+2"#9(7QI@1_BN[O00_1L`@XJ>]O0;T2V(<)7P*-B6E`02Q0@F
    247 MA<;KNXBZ%J*"?.%B)(S1<:Q37R58U`H4Z6@M.A*>V'/P$=D(Z0L9BJXOB>*9
    248 M))P%V7(Z+TT`C'K9DP`MAU(3;9+C)_VJLA(P#.?HTTFM9$2A#[A.!*'!TA/`
    249 M::V8G,H]2A5U.]J$B5H64H2`"Y_1X'P&HY'F$J5UL@")@.R]0G*PN1U@MG,M
    250 M''B$%BB:`^=A%"3),*O+ZN,Y^0N.5_N+?V%CL&9Z_+M+)*KK!I0J&,,$,97H
    251 M5T(YQ4!@Y0$-!?($ORH<(05VM$9/'+42A3!X27DLPG&Y.KE[0AFB=04K%?%2
    252 M,)!!!HG;*]F);&G[LB$/X/)*1`BR98F[DXI.+H,9)^<BZ]/V$`H0A@8D;X^1
    253 MKIE9+>RS?KFAT=IP+3F*[\D->H+AU%5KKYO@DDI!"@M<CA`(P!@/*H&6W`SG
    254 M3/BI!!:<_?)P+4"KA39*$9JM5-^"KJO31(1,VSQ!,<FY4(X`K)]P_#+KX)NX
    255 MQVAP7:][NLPI`F,N2Z%NP?+C.HD/R2^(@(GE#<2#1FF5N`B>&\3&4R3TR<XY
    256 M8AFG+J<CVX>5U>HPM@3[&[%NDKVB39.6U.A4FC`F=>,:SK+!;+7K+W=5)2F1
    257 M<\"'3B!2_86X0U(7\5.Z2SEI,BUD&_D'FJ?(!RBL34)%N)LN&>Y`E<2\^F7]
    258 M`Y=<*&39K]?N63(DEL3X6;+(>7M8`B.;%$.B%NV>K!$+L52*<+3/E2N"D>($
    259 M.\5#K5NUKE'3(Y4%E90P%:!!&?9,.<,_*DTD)`7%!"LW[CH!A[F6U'G:_&0`
    260 M0'"JB%DK(&*Z55D!@,)-URX@5S+69$P=>7%MAGHH2V-%Y;G1ED(PZVS`&HAO
    261 M,.ZIZV)^DAZ<V(NJDK8V`TTBEM@V:0X+5-EC!4Y(Q""E!*;'0!,4MKRK+P>.
    262 ML7.!22J]KFB@&X1O!LBXW68D#)LCIXA\*=J4-@\`0D`$BGZ*A;6:!&")Q!#<
    263 M7D+O<!"GB$LBN9(;ER(U0!Q&LK"N,L3:XG$D&IQ.*$E70D:T*PW6+CI#DQM0
    264 M'*C=38#<2%&DZ`?<?:M13)=9FQ2<_VJ194=DD<CL6%U`T43,F*GI6"4P,SR3
    265 M]*EC;*I-L\(S648493-2D5)`<O%JD(IKH<A;D-D,&EXI#69`8Y+I3H%@@))J
    266 MU?1)()3NNE0AI)761,2OD%#J/H+A*H78B="YNRRNW\=9X5S`_R6J]M2SW>)`
    267 MEPP('!1#R]H$G"VF!*_![TDLJ*9*B209`R#:2"6IDP$;+25A,[$^12Z``?V/
    268 MZ%!?DD0"?T=@\^5:I<*D2D0*B#D6!^^O#=3S/N2K6FH`^,A.N0)'#06WZ)FZ
    269 M4GL)$>BSS`:%!<12#]I=]\+P4W=?=G>"UQIYH*Z*-U?B',B7=-ND>L:CM1.Z
    270 M!(`B)@<<5VL+7EC;;MZ;(3J,C+^L*TD@``([Q8R),=>ORFY).NP"R/1)$F-R
    271 MP93(WX4+ZN")TE]G;72;#%^BHB;CI`W+X&K$]>3I>'I@.OY"7$"\*P7='`:'
    272 M8%)5[U05\3*RP#R/O$^D&$LE%:@#3]W-=""!IJ@#@)^!TQ5_<&--PC-8J$D*
    273 M(;U)V'6BV&X(5$N,NX)\04X7P!!D*@HE0-=4PWCT04T^B/K!!!M!D*`)8/3!
    274 MVP+.8N`=T>I,BE"0?.VW9(B`FGHS;`@T6=+4R2>&T3DGB@UPC(1U*C\BTP&1
    275 MFRMN*/X]V!2*3R1ZH.O30[_N]EY"*"]-E8XJ,7B_S&`WD!G,>5#JBY:#EN%#
    276 MD5X(%L2GBD8HI?&M!)N`4I=6,G?7UB>`9`'2:IC5)G=$W8AR!BP"U*08.--'
    277 M=&O2RMT_7GGJ%EQ9QB-.RBF-1%@&3RY.SS(H`%-XI7+NTAWW.C`1`)NN_U($
    278 M(K;3SQ<0'Z6)I!O(206W=!DEPVNA\E6)1T$E99NC&2;4<Z@'[2X2Q$51+$@T
    279 M?`Z>LE'1K8S?1B6D4LT"0A&/2%(F18Y3NX#U)A3210M%*?T4X7Z@W%>A(\B^
    280 M$]`B!7IGU?<@/%#*CX9X++H((W"=%.WD(P%`E<I@)(C?@/`![)B.!<*7"75=
    281 M+9>9[PBZ"Y/%F.Q`64G#$[M:7?)O.'Q<&SCE-,2"`W,1/Q.LDZ524_:NPL>!
    282 MLS,YNG;WD5`J``H01%<;&>`EM6/C`ZE\'_@[U]4*#!H4@I0=]DZIQH3Y5B#;
    283 MT"Y)>ZS>*+.2@D$ZCJ$'$*Y43A)8323ZQ$SB(>2J`BE*V=PD<3&X!MA8Q&&\
    284 MUC@!4Y7S3]#H:HQ&C[N(3X4*ZS2%@8)!\EN=/`([!30C9Z)XDH'C%!5D6$%(
    285 M"N5'>3*DL9""A>*,C+)LLLO=_"0.L&@'B8O2K5).^$/V0RW;L(@\#]4XX+N*
    286 M)B6*(ZP+"2GJ8FX3^;DKP5(0H&^J\UION1U0`ZTNJ)U3<JT$Y1TM/*$M5*]`
    287 MS']XR@:K8)#U5>)QK9<_FUT<(I=E8;*?+3N<=CH&0-M)P\$(.\\\7,$EBU>H
    288 M62G94^27&`P\K]1GP!?(*R`"^P3SZOBX2*E2"GQRE=5)5D(=M!8-9RK/C%_3
    289 MCC,R#J0M4Y8%B&/`>R#*[$N(.KPV10>%>T\DH1V@11>)9F"!:&<T$\`<"`?G
    290 M4\"Z0:PP>`'#!UY`Q?^4"4FF(7J!VH*3:H6&Q]XQ/\]&B-)2!B]''RG;)T!/
    291 M8K%"&H'BS6!H0-$&$(_'_`]P<;A+@9*XU"V1>6<(8>RMQ!A41E$2I2ISEF1$
    292 M=U_9"6!R<AE!O@>/JOT.,`('N&P=0%O8&1=OB<5E)<`T!LP,,^A(5!?9+7HO
    293 M(UDWDRH!*V`45`)J<"B0O$2@E!!D>!-]MD&TS`G3C[ZR`WQ+C^%;&8R6=!N@
    294 M+09<(3]U@M%*="/[59UA5=/%2"V@5"K2(28F:R5Y!(F1)L@TC</S`6Z%O!*:
    295 M00J2C%552J%V;]2RBK4=Y`)T8[HN=T/2\8A&+F#*3;8%QPNTH;5ZV:M?$?H=
    296 MYA9B'C@G&\^,2N)N!0")D+HY2>.P:,0$2E/"S!$$1^+,15G0]8%\P&HS=N=(
    297 MW,`BI(A45!LQBQX_HL*R>7)UK(7^RO5@:B+PR""U--D\?05BW,28D!=1N88B
    298 M"-Z+?TM;$>!2T1@SQ8B&"!.MDC+"!3+'H(0_S1,LCK?A/.E!H!$".SESY17P
    299 MT`X33=86+B=3*[>J"K@\D&Y/1FGT-=(QDAD\8G'904(XEJPVXB%</BH(5@3E
    300 MDPIW(N'1'A$P:ETE<QM>?TD(97.-/1F2[@3.B#M3'P&7)@M)6B`CA`/%_.)2
    301 M.U%PP:4C$`H0`6(S7I!?&F6O%45@9:I;6"1E*XHF<:C5Q"OX6B&8F02FD##@
    302 MI,5Z?F1#ZV>EQW-/H'P$3RG3JM+,#5N7^9-N2OM!-0"FR\HAI41PWA"OMK"G
    303 M"9Q!RN6#Q3F::+J&":K.<>6ZO^Y@/6)Z2CLH!:#Z$-[@B,GFRAX;1:B<Y$Z-
    304 M4O$YAD)[GDW;'";S@+%ESDK7GN$Z#$90:,%B@VLJ'\]GX@!F4QDNO$PJ#H:-
    305 MT%00>\DX/R\OG1QP,!Q7&PTI8)(?@`+`,>'_">W%J5#Q:M7UR1W?OF2&BE)J
    306 M+^3?6'0]@&D&>BI#YD2,:_@H)$?7/%$2T)Z$4ZOF)!/==:,]>#,YKG)W!-2_
    307 M(=J8/NJ]D00'A)L8&8813A#2-Q7*231#DNLB9:8F:H>&&X2Y"#VI8?7!D'&$
    308 M)^XIZ1^8-WK%#2DZ@0T0J>U4MANT+9&;`O^"[]KS<A<=TLEH#CB5.1`J1'(T
    309 M>\\=\:98@J-I+"QD,3BA,+5`E<CH.HFJC"XU?(*#XI(/9AP+:OXVRE9<@2<2
    310 M`=6%@'#FE`["7)BI@WI5BRZ!4WHR:0BNIV4`)XH_DI^0-@)V!YB],EP3?UNR
    311 MTUD%?]DX2Y@G=/I*B8P*6852";FY.9$CDX%YH=T%LG6E`%#,C+F4',P0XU`>
    312 M@M;*SA)&$DBC%J4\8LX<6$PM%EVLSF7@Z\!@`D-EDXO9@$YU4QLO6[Y!YD9%
    313 MA8FY#?("ADZ!%`4S`/M%!<VFY\_=Q7':4J-.BPUE!P#VH5,K')VVWA&S/YT\
    314 MGYP6D`9B%@%R&N$7B'*SB('.R1U&2/P-2L;FA2Z@O-#I)@JK.X;2#OZ<G=-D
    315 MBDT=]:E4AW;',D%;R8PZ5$?`+5S+G$MJ8!QTD@?L5M@]A2U77@PZ.#B0S[K;
    316 M\$A9(?RSH8KOBLGR]V(MHH09@YA=27,`=!(`#;DBY1]J%7K$V+::*I4P^C%D
    317 M"`CLZUCL5!!Y<D:S\DQ%!C;+FWV&1R-+2,*F\`W]`,:8CFC`:B@PRH@"*X6C
    318 M2"G?0?`ZJ+SBRZ'7R\)@_V&EAV@2\P1J]!3MW89V3[.&-TFU46:;O@=)M3:`
    319 M8+:"4U/(E=J>BG[KY!_MNI-^B5I.Y@=%*/Q*</0OC2J+HF6Y[MW.08.)YJ^4
    320 MZ*P95(=T&F`%Y"^Y`&@$]62YB*>!NSH[B5)E>ZQL`G@Q!37`/J/\?BJ_R=UA
    321 M<V@F8.XWK.Y,5;/0SB$+AUF8!J)#WL6[&%",QO3&8J\90^^$C<7L;ZJA@$SA
    322 M;"\F@`^L3<@/$,8='"BAZ1"NP8TCM21L]:,)F#]_D-I#N*J.%J%O2;PB7!LY
    323 M/-`:):.T9S0#W<EE4%)#$%PGX;@84D)L8S*+%.D%1=+38G=`#PSOFG`?7!R3
    324 MHJ,0LO.->K)Y'@"C+UOPF,`UJ:U0$F:[H"T,T!38AE1R"*>:I6*Z06&:HD<\
    325 M`V4PK/6FRA"H>$I3\VJED";B/>52.C4+?0O"2#*15L%"=SD)U`M2L&3V!$YI
    326 M/;6J8`IZL@A?O,)FIO9!]Q(WA@\A?`;]D^Z`]'J+6G0]`OVFH4>/!@1&+TN`
    327 MN^<*&E&J;EC;2,&@DYY,@CL`/UTD.%N?1I3.Q9MKHQ@'L1^H6,Z&\>'D(@Q)
    328 ME]?`.\*>P[>/ZFJBR\@4]$$Z<8N4(S+Q2Z4/(BQ^C.2(:$$+K3@NNEDAP`\#
    329 MBAN$X[9()!"P.>7@=V#J2A`$\@NRUNPO(9H1/!@(ML=HR]I+[LK-+I,W`>PH
    330 M4\=S->C=L"Z)#1MI,GP/R&Y]4>8S]7?M&"@]9?Y$1:)PMAQ&#.R+H"[N==("
    331 M!Q)6G4'>@.<IYH#"S"8!R&X%Z-B,V1VL>Q6@R>-,3-.&Z$8N!L)/%3U13#+-
    332 MPX&4+L&-`)6Q+V2JH)$P7[3=S427/0&PI:/`#WX>B2F!X."CE.$_8,0WUZ;A
    333 M"6%F)O559LM[='QR_QE9AM83NI#B#<)"IT$!EA$40S8A<.<4E&!0`IT2"H*-
    334 M!"H#(*ESJ]Y<$"77^2O4C4BC7P#9`%-/)JQ$OM:<N2W&"P`%E6L(..`LQ#2%
    335 M]BW0<\K9+"Q'$6`/B9<ELC*Y5D`P%NA3G<"&RD>&:.KJ72\;*I7<Q9%,L"$R
    336 MH@(,#Z/YC^B>&Q.OLBY4W,93Z=#Q_5-RHW1'`<^T_^`R-B)1C;UC$RC=9*.2
    337 M`*ADLK3]1??&R*02.M`XT+?Z#?!/Y&D5)D2XBP"DA&FFAIC)2RL6#X404PF*
    338 M1,\P+YSQ$272#X1WB\D5=^\(HI7I03%W'VIEI&`*2E1@MT%`3IQM8LYIHJ_L
    339 M3#FD%E5-MAV4F`,Q'L6J"25)TDX(#WA)EZ/2#ZB>]-41OQ!*-I\<0?Z26$1H
    340 MOP0ZR&(GB"(\P2@3W&40&'+*2:8)O@(X64CUB9V(X`]<Z@H(6:GO<&PA8(-,
    341 MYH0[4%Q6A]"`&2-GI8JM-V=V4&IV%E$TA!XIPG0M'8]AND@!/%'00!F!6O$@
    342 M@Z'Z&1WXL<,5+C@EP@PPH07?82F`6QQ8<AFRVR1!92%RP11"!\IDM-I<"DZ!
    343 M"E0J[DYUNX3+<8:%"%SH#U%D#BLLN:A)B1$G04<(G@,5273X:/M9!:KWT_RB
    344 MGAY@*>;QL(4`5\G51T4*MHZ#$CG=A7"Z@+NB\RO7Z1.'F"@(/%KTJL$)(/9B
    345 M(\!Z\A52\XPGC5BY@`PF=T^V=<C':R21WUW)X\#BE$)0"Z^F>3:[#RH2<',E
    346 MQO`#9;E92&W,RZG'DO#;@`:<0Y,;'&T!"B5@:TZD#%3G"N8"V%H1B_/F^X-P
    347 MQXI*RZV4$VDR,,8/C$^AB&8/"%<$.-!`82U+!N_W`'(,3\3P&3X/EG6@W$`&
    348 M+W]E!@JE4TI.U!+IM-IR(@)4/..DSD1[TG"M0)L+*8,"%,DYXD2UH-.`"J?D
    349 M!`"Z'4O*0TT8.C\%2=AD\Q7#=ET$3IK+*E143TD2)51291EDI*&[2Y;V.K.E
    350 M@ANALKOZX%85FBM;WI,EK%8?9H<1S=%FT8$OAYT#Y%JZNA,X"1:[(U![\G.%
    351 MIPE]%"JG'A`^+?)`HNN6'0#K`9*4L(W@QC'M")C;EYR&PH2>1(D1CM5JI'2_
    352 M!(DMO2M@8E`;.2/FWNRB!,6+:W>)C;#--6-%OARDD_@Z4#,(-+ID,Y>V?(KO
    353 M$)SB5X'C[7-!44ALH`!1/42C2#<FY7`9EBVM^LLTZN8]N'^*EF8X4`:AKNM]
    354 MG@ONQ90,L([AEKT).T`.Z;'+!?;DR"8K0P2!?NBDE!B`Y@(P:JILKM1`1]4>
    355 MGVF6E*\().G2<G5:4D&$`1X-PXCK$%=W?I\UT&9OF=>5CN,V[2KI-02=[_2,
    356 M%9/:*UPO2&B5#D!\.*7G$WA$1D1-L[D\@A<WIY%^"$AIV3`HV'^FSDJ9'MNW
    357 MIV)$KI(ZRNUR]^8P<1TB?2C6#2I+`D-9=(8$_>F$^-Q%-3O)ARY!#RA9KBPS
    358 ML2#@-KD"03F]W>F4FUV`1_2[DV;?/!=V6(C5J+.8^0X:R2-E.N1D'SGF9T<#
    359 M*>N2&NF;SGN-9&.32!<G#&)VEHH:K`V2H,<DCV%M*?L.P.G0G^0F;$@(6AMH
    360 M0*1K%+Z'JWA2EG8X"1H#&&X`,0DJ;7*;.]4-"NGTU\,N=?F#[`\:]]P=!%W\
    361 MV'[Z*.7:.AP.3+(>F694:``%@@6$JT9,]K)Y8.00WE9R,S;XO+GN4`@:<"')
    362 M(5D-S!'7]N@T*IM7`'8FD&D.2;+9T;2^>](`J"E=,RMS*1`T]A3T0L1#N$]5
    363 MJ$![&<175/S<PCWJ:L_*+O)/G-=AS#.X)(1UW1\9)A%$L+TET1VNT%9JPO"$
    364 MV(V<TYYH7@L-LIE:'T"ZQR,$5Y697T')`AL'S%0PHIBX4SI(<99*=#=1GL>G
    365 M:QQB!T!JH`#6"8E=GZ2FT=N>MS'>(D`J@`)L0CXTB0FPUUUEH->7?,?9&>6S
    366 MG3\:S=QPW8%6MD"!FBZ6!!R8>!HX5\.Z"ZNEM"W7@/6$6X&_!A.$L(XR01C3
    367 M?A'/P".;MUUH.-_Y7+8O\+_=XIDA.%2:O9`O63VS-K``C<A<1N7$-RW^P"3V
    368 MPN<EN@$212E85/AF2)^,!`%A=X"^,Y$XP)M.!3CYMQ21RA0AG>X^0M=SXPAM
    369 MF/3WQ[[SA:Z@W^2K)'>`G=UP$^`55BHZCEN-V2;0+K;18?-=P:",[<(<P`N3
    370 M$P9Q*^V4GC%"3I#,:T@^Z>U53VPGZ`R"K@G9MU-W!3?47F2/:7'#!MD[Y@$J
    371 M7'6Q_F7K'P*E)-B&?0$5`CY*=>D2/!.O.XR1#,=7,"->RM%P=$6Q@*QJOKD3
    372 MN`*4B&@;+F;.`,K8&!;.Y<M[(ZU'+2B\IJX+2[RNBC991UX\*RC8<=I>=?>%
    373 M[A5[6DKI0C/GA`4O:"39F,2N`BI1?G!?"*4+/?=65J=#TL1XT(-FKB*%3(@]
    374 M])5FVS;%K1YVH/B(LTM?G]H]UN[)H4&"R(J4'*H$Z2RVFM\S`:2CC<>7C:@R
    375 M<<50/%6?DEW"JCA,ZJITY(([PSJ!*G.VZC3Q&0J`4`2;`YLXJ5@'FI86!03S
    376 MP\;U4,XV/3LI+<0E"9,L;0^PF>B#AH,.&X'X!OZI@?635<^$=*`_G=D!\&J9
    377 MH2*MCL8#3(XPC]JM72/N-IU8VDEY`C$B-`$_[H!:=")7:J9,-'(?4`GC1'$V
    378 MB\:-I3#YYLKV,[R0EEW2K_;X$$'A_>A?=IJ5Y1(2+28?\F]P'8NV3-KALQ-]
    379 MU@]$4MMP(N6Z>L8$%FJ.&=@;'X@VTUE#UQ^M%)6"%$2^!R(\I0\SP6I?[KJ[
    380 MRZZ[:RTNXJE5QQ,9TLDL!:@))#ST%<CRP;3(CLT6X@!-V#0B%Q_/Q`S8$OH)
    381 M=_907$,^.,F3^N+J*;5!S$Z@9]EJ620#?=$(87UGPX?321TMZ#(OA1P(>P;'
    382 MAO+JR:!A;T!.ZRK#@)$$FG:!O6A(GJ2#$C;Z,@'A'\Q9_OG#\%0,6-T&R*@`
    383 M(='0[)US4QC&P%I3?QWW<"6XP8C/#IIM"OS,QK"%2<F$%B+G,A3.TV8`%?IC
    384 M@=:X$.H[CN+AI``\$;W#IZ@@-Y*:W?9=$E:"\`..'3P.@'?=:G5/.^6_A!LG
    385 MZ3N9O2NY+3E-]W@(L$6JT60OD/U8-#"!2-DKG4P>>0;X%W$1%1[#Q0@B&6,T
    386 MSY[7X3=/GG*3IT@Q@+)2-KQ'\P8-VX13V`)`ZPZ[Q4>@UNTA`31@FCEI@G]`
    387 MP$M"!&F:G`:D;)A^6C8S=P5_9CP5F@8AD*[KZ?")%D^W=5%[@B2P6[@KQ=-D
    388 M,BC\!>).:@\=?(ZI.C`CX8G&=<CH(3_,()^5W4UT]R4C_G07T+2V:*OTYV6C
    389 M@+MAXPA4IE!!Q^DN6RATD*Y5R+YT]5%0M?.&T[$9M0N\^&IQ&=!QJ407B,#.
    390 MS3Q6`)I]88C'*<PC%Z(L!CV-P4*>D$+#43?8#/)%RRU%[H4A'<A\,LF"1B/L
    391 M':X`NTOL92`0HCW0B\3NU!I427U,_P5ICZ:CFS\#QX]"+)UBU.3R&7P$GX2N
    392 MU8OYJ"3P+E@VG(6+-1!U:<`[<]:P7I@>EM28WB0-\?PSHY7042EWR9[4DX\!
    393 M1V?-V&$P)0L"P"\#AAAL%FBM-"5R[%;K0JN,VXDSX!'0'.(`K"!UHDD.(A(E
    394 ME1-7[.JB(G4LO![]LVFZT$G*0MS,]@US4-JCK2H_?YC=8ZEH),.<4CR#D5#=
    395 M(C^H;6CY7HU4AB1-`N]Z&]`"]&\/ZL$O5`]GF>WV:1P7T#B('%,:)(&0;Y,+
    396 M&,@7"1APQ9=VQ'+D6($6@6RJG5Q:ICY%@QN,*?0Q[B%8]O2KPE@+VED8*U&J
    397 M433:&B&U4P1L9?L*?HUI631@%\_F\H@_4`L,':J.D>CCY33JBI0'BA5S*OB)
    398 MZ;%APVPO."T9OL7+CD70V@=-8Q)10Y"BY8$@TR,SHLURGG>+@Y23-3$IIWHP
    399 M!`SRB0LJGLL!RW3XW.,-PX39">V8>)NQ#PH.S'QA)@PQMRUDV#'+"QE_(@P;
    400 M;L'!FD+`6M5)-(KV\!-&:014H;F+WHL)+;/AOF'CK2SPB30!G\H=L73L,(PA
    401 MNMQB^"FZ?YMI=3M;8C&QHN<C@L.9$$=G>DGN;.Z.!??!BF8=8X1I.%S3)*/G
    402 M.:QZ-\,33Q`?*%9R<H6[B6;%$:I##@44,`A[(I(Q6C"M9CG#P/0C#QKG\4ZP
    403 M/>,#`@;=#MP./A]L6N`-FHIA=P'^L)-GCL$5S`YQY.D3/24$8X.1CQE^?F?2
    404 MP\XMN$)1(BBCCX_&$G`%ZK>02Z*+BZ3%)TB+,CWJYJ%HY(0DURMJ<W,E.AK"
    405 MB4[0'7%4!QR!E08W\4PB8.$.V'*:;.+^<#B&@^"<7)_B-.1O[:#4GH)W3>=^
    406 M6+KX@`-6+SQ@&\$.'"0*R1BU+32S20[N9'97,15#:$2!+F>L+3"\0NQ'&*I"
    407 MHZ4K@A%5:VI@XTY=IX53#A@'KQ@<_>6.AS*#$H^*2<8FT[B'@6#\33.X3(T6
    408 M%M++00L$BRI&'ZGQ$V1V+"HS0IB:PWB8!4!*S.YD<NCM`!Y,B?*H-)HE89=3
    409 M4@-E)FCW]^]6^`K,3G@!/@J:WVB0Z\X`"5K`:`8W.@Y3#%83J"LRF-`U+=+%
    410 M9D3J5JR@HJY?WLTQPQ$HW9*'H^_115@/:<OPXAC;!SQ=3B;YVFVHB\L%D'=I
    411 M.6NNP<)#I@]_X8#I;)8Y%-T$62ANYLS"0Z>5$?(6\@>>7NO9,E_H%(2_[;Y/
    412 M$ECB!&M)HRUONO]M!<T;1P<\DPXBIW2`E,'H"L%3]*",N.9"MKY9Z`L9%G,]
    413 ML)=T:S&0+*SB9ESU=]E6$N"3E;X,VORZK:+R6J94-9-^J8_Q(VY@J;#&3]4E
    414 M=QB1</1D?C><+N9!,G31YLBL8>6>F[7F('KEZY[VYZ*7!STIX`PFKGM(CO1@
    415 MG"HX5P`D`WV8(>J]S%>"N4S@R\`=`E[J,?7,M(XV$IV:"L7:;#QVKOF$[L$M
    416 M,"JQ>1M1#5E-A@H:HW2AOQ.U>JQ3HA&#^8Q:D5.!QLK([(AQZ^L&=,&03:QW
    417 MHZ^U/O)GK^@/O*0"-X?8`%X=+;D#CD=93;^DE@LI.)A?)D\T2F$4*5!*PU]@
    418 M@227IJF8O[&+5#1;G)D]M`7!B&RK89]*-,VVM&S!72_GR5C9+7M*>J#Z4:AE
    419 M(*%S*<QA=%6'D62[:$P^":>;YMWA^:FP)6'J(>T`/^G6?'1@NXW1')7('%B+
    420 M*,DW15M!,%&'\CP2<C+48":P-./BKT,)@MY%"Q(#7/428[NP:L<*VO9RWHS9
    421 M6<!@D<YK9I-(IAD1`AO;,#01]'#W<C?U@0(4#3W(S+V\1DD7`V8<EU@!$`/R
    422 M/=0Z=Y2YXY"):8R+"2#KC'QT9++AM''-'3&<R;`P1L2BBE1A&`C6BQ,*L+'B
    423 MLEFT90!9J<P?/>!B"D0X+H!5FT_ZJNE5`&PP$X+08C*_TV1WLBPG1;+/+X?Y
    424 MIV6722Z422D],W:!MCWRANFATG3@!%/,H(UXD">5#P#Q+X>_PDE1=S=2"E^+
    425 M7)APASE6"G.CL7,*/8SBH2I0NZ?OZ'M?#A=&I6&:G0-+LBT7Q``DACQZ_C!^
    426 MEAYI6/(XP>Y9W4AZ.[`,&AF)K&-QPIS-+6<EBN>#!.`0]TIX!C!%THD-S9YG
    427 MNF,;0/>8Q6"B88MS]4/3%DVK-[YSL:'906!31K@-<!_RA!WK('B/"TV')LG4
    428 MHQO[V[,$\4V1"B,#U^CA(V1E..0#XGN%^TDKG@M'9BB;(@ESS.-.W1#KT@VC
    429 MBID^XBD?1':/\"\3+LU:AI*6W9U:`2.<F;IC"V0%Q!"^&T+`&(3DOJB7,]1&
    430 MA(QB4L&&)<C\EF:J.YP!2`>@+)1!I,61$4[PB62:=\`#S"D;;8*LY3:@[AE6
    431 MP``N$T`K@B?7311UPP)<DC-(>P'\`,8U,.JNO^*A1-D^'&Y-C3;+QF-@SU'I
    432 M9$,>JG`@ZFYY(:AA,!X#TJ&^!L9S8E\7:WX&\/I@,D8GJ*3-<<<Y8.=0%W"Y
    433 M`@H9_"Q26T:R$G)WMT,SQP6@C&E,U3,Q'G#<1HCM:1P\A>XO>9HBG$R/PX*#
    434 M`(^BNF+**#W:7:)G*.TH2$:W,R8>[()"KF=/>DE8"=PF10@3*``[Q\+H]&`[
    435 MN.M>G6(+7MWOR+1=#RZ`A@)VP4@>>$I$-7")"0@(4L]-]A1G<UXS'V`F4?:`
    436 MS$K``M=B%59`_:>G.C.]M+J]H8V3'*)*VDQ/)F6>)`-.':;`5S/K&TB"K(8.
    437 M;NA(U189%.ZA_@J5F<'-$!?0!>(8Z&$9(P1'N8/CY^BI->ZF`MS!&.VHBOU0
    438 M__D#_3D4*)K#Y6K,4\%6NGN8B[L,996H<"HXI6:^2JN;]^"6LJDFIB[24JM8
    439 M[F6G80RFFM(0T-V"7SPG:;O&ZO(H'@\"2@>#M[QL/`PXE-&X4G.UB]L\[+,)
    440 MQ9"YX%60\U;:$LJ63U`P!H\@M:M.U0$SVI$\`-HP0X*-*!Y'(Q-Q3Q3T_>(8
    441 MA:)#<$LE`G@.U*GW@.:XF8BNK>@!%F?`A&HH^4QV+P>T.L;>G&)P=(V6-6"!
    442 MSEQ3ZIP[(G(A%Z;B0H,O0Y@;'K$]T+A81@9FK)$PLC@P6<XT+3($NMCH\F."
    443 M*`E]V:-FNK>Z><>,*0>#Z3OFZ84!-&)93<4'9HZF36P@AN?"`D28'TQNL`>Q
    444 M5VT(\\S)BLAX86)(T<\80O5,:Y0.NIG'VIY;M3J$C49#'CE8]P2S$T+`I"_F
    445 M4#(UW8SFD=M#@Q3E5F:7N`,3!$F9U[Y>9*1,C\8'48GNYTC26C44W5'T;<Q^
    446 MX'@#2A<,SG2A+!`=(\&6GON<R.S1Y+>V."QIFCXK@>F_T3J/J:-^:?SMB/]A
    447 MR:RA:YV&V#70PT/[C<T'SRUAMJ+5_Z`$T,_=X&UXO)4,D!E@+OEZ#"G57_D1
    448 M/?SK#=*HZ&J(H2IZTA!`.JG"&M5*HD3_7@SW;R&%M&>0@Z!4--X#:30CMW2\
    449 M>8IS8*#2RQ%%7B&V0%CHQN/HIH#6V\PYH&@-XZ-2K-AC89A1Q(RW9E43U\"!
    450 M"!B3&27TME#*.YHO8:XQ791`WPUIA*C#`UR;IRY`"R7X#5N0>Y6EK=-=->3D
    451 M`"<4(A@RZ7FI'I?I^2+CB&@OQ(C0(TB6<%],H6QF=0`"0QYQ#S@`_V;V`HFX
    452 M^WTYL0%JBY$@'X(!F`<%F#`KEBU:C4!M+B/Z!(KJT8]N39UK+ZA(\^M'F>WB
    453 M?G$;$CY)%1%^&2-NZ!2O;NN5L7HH\T?/MY@>JFM:!],4&-COY*6;XLQ9&N<`
    454 MCXDC;EYL#CV1TT55,LY!J=?CZ(DA3I5]3#N-EHP'"^[NI1;AL,X##MT^"NGR
    455 M%+X5MPPA,.[CG4QR-3;BJ<&>Y@82^%!S(KO-81U0T$R"(,XB%^/<#8;WP`8^
    456 MUYOHJ['=Z.[^APU3C0ZX,9LF`0Z,H3EF#\(`OCP(@<'G4"3P<&`4,7@.`X"C
    457 MQ78K--'P3^PO03/%%$([P`',Q.))DQX(/?;@REQ.2BF,:HJ`CW4-2Z'V`O""
    458 MK0@/<SF8&E?=;<NA(I0925*JVZ$\K@O;1"W[@;GC+*%ZAA#'!113YL,:Z<+,
    459 M0P0MG0OC].ID'SC$&G6/C87A2<&,PR(6>K99;&\3QI$A*I0TB@]?B.Z5Z^Z3
    460 MA`2"44OM5!?\4>MWK+A-.PU:GCX/T!G))(U[OMQ7F7C)O32<W<$,);I&6Z[;
    461 M1T#<QSIE`YR4IF0J!5J(HXKH#G"X(+2N0CDFV=J,-S4H;G(-J"0<FV=G(L5D
    462 M@IKK::"'\*=VMW'%K&9:G^&DD;8L[.7`HJJSH>$8W5-0LAOKCA\P4S2Y58#8
    463 MO/J@I6T4,/<?NVNEV6-V=U,=U\1H]TA[P'DXP1%H2`<WP+"2W\%2V@UP9"9^
    464 M97@336R4^?L&'EQHMVH>M4#!K)K+<-C4W-Q&"4I!)TPV;'58SRLS2JB`,+)@
    465 M#7B2"]@,)7VF5+_)_<D\YD,FS+AD/(;G*',N5$WC;/\@2J\A]I!QY[F>GQ=?
    466 M(3/TF_9*#@'8S1G#%X,/9&$0M4?&/'"!F/U&KS&,Z^`#-<[I(R>'^?2G13DQ
    467 M>G*R2!B>Y`-V&IWO#"UZS/<:.@1?L5,K)*W<B]G!8\@`?IH[?VH^6Q4$G%^5
    468 MAMA`<OUT0A,\RY]4@RJT._!/CJ#P)EVT=%W#>(EGPW"E,N"VZ=[<R<>9/6E?
    469 M!>:N>9(,Z*!Y<.DKA<]T=4RWT-U%%UCN)6UUBD8<NGELHON7W1DSH^+EP(#D
    470 M'B5M][1#V_?K/.0ZL9D'S@,H5C>TAECRY;04\J`ONW@`>7YI>^VT&_W=S%]>
    471 M!=ECK90]UV-E]/;)&FV*;T)^.,<`VL`']EYO9X$^H2D<0!/.`IMNA(][<OIZ
    472 MC-[XV]__DO[XNU_2CQ^CESA&[Q22)TY?VP_"NIQJ88GCP%X>7OK^24;))QG%
    473 M4_8A$[<EQ.GA>J<C1_;P?4-.SZ>,I!\]9>1(U?F2/-1=\KQNDN##L/H5+>7+
    474 M^96_;`C].G9^G_UR[>?K:F%/P\<>%G$=\W[NFMWT:D<[3W>!O=LF&)QH5(]W
    475 MJ(W::=Q^K?NVMB$(+V=Q813#J9.HG!]K\OVMVO,H'/2"[91]VZNM)::VS5JT
    476 M[<=/8NTK(?8GEN@VFB]O@GS[."=([A3@M`<F+P]K`R7O;I7\`F>_'X8IG9Z:
    477 M@G%)6R&X;O*>'\2="D?:_?W8$/F7W<8FHU`O9R$FA1[GW'@+/:ZG`#!]>;C<
    478 M]$]OSUWVL.4NY;8+VB@?Y7`'N[:VT1_3@E=+-?_V]W__CW_^_=/3_039<3LU
    479 M^^GI0_SCT]._SOSYX>EI.SE[["=GC_3^]__QW_XDK_/T]/,??DG'6;2CK'?2
    480 M>B=N[S3.P?ZGWX7_K_[_^O#].*][C/>__P___M_\_F_^_/SG]__P]Q__YH_Z
    481 ;E__R_.<__?E_/$LF__@O?O>_`'X[0=:FY@``
     1begin 644 zahlen0.res.gz
     2M'XL("(<<55(``WIA:&QE;C`N<F5S`.Q<VW(<.7)]UU>T]ZFIZN(B$_?1]CC"
     3MX7"$7_9%^S8A1[1(SHB41&G9FMAN;OC??3)QJ>*=E*C5AFW.-*H*0`&9B8.L
     4M/$"57O_EW__SSXO%@GY>?/K\Y?33^?+SQ:<O!Z]>O*X%_//BXO3\M\71?FU6
     5MR\WJ[>IH=;PZ.5@=?YXJV9\7I^=?%N=K/^6YGQ?]W!\N3H]/-A\6I^N>%PX7
     6MF_\Z']ZNWB(]6ATA/5X=(SU9;8:WP]%P,K45T?YZ^^5X>0K)?@GV)WY#2W>P
     7M]4M[L%WRP7:[#=NX35N]1D%>>IP$_")^";]\,&[);)=D<$$D"4MB#T;Y(QI;
     8M/:VC>3RV-N3*CM(T3MPXOH"5CG\_^K(XNCC]<G(!N_T4S.+HW>;T?)9%.7<5
     9MTL^+OZHA_[H^G13+/R\^?_JP7WSF]?')L'G;2\BT$KL^TJ*CJ8Q:F5N_+86E
     10MAB;'4SUN]?RZF'169J?A(7>X^`AU/IPL/E(?(,*@?>:7OYV<P\"KGAMZ+AT,
     11MG^V-\HARV\O=C?*$<M?+_8WRC')?R[NT;#H\+TZ.7__;K&0"+C+_^,=ROOUI
     12M(3!>:&5)_[(Y_:#'=Q>??O_MG:#U]9>+S9>3W_:2??+KZ?G)XO?MYK<3N?'C
     13MYR^]?=BPVN9,$?B1*@1M@2`O.0%:=ND$4\X>`!WC%LCT`C0O>/2"O67`=5@&
     14MR0@**B.Y44`8/6"%@V`U:N5$F@*<4>$II8+.&/0F?U"JM_RT3-I:8DV=8#[I
     15MJ=9,4=,L]6MK2?K*1F9*ME*:M>4<%?X%_[._UA(ZJ]+(/$DB?!*-4(K9U3IU
     16M!^V.<=)%S"$:-G7L`>;<PW^8A%>OK=[.,K]9A.!4A95Y>:VNQR_@!R.^6+[^
     17MR?)UO6[^W3*S;YG8WJ2.$-L1>/[I.CK=U3*!X:S4/X#=IZ,U=+2^_X>AM0WN
     18M[6B5<W=P':T=W@4Z@DTD"D'!T&/0BB0I6-'6'9!U3=!'0S94R-II-HG$32GW
     19M.,P^"-J[`'L5L8]$8NRCC\?DV:L79[_0F_5)=:&XXG;%<F7?K(^G,M>NM,R_
     20M61]-9:%=:5E\LWX[E:5VA;+6.YYP[U^]>'^E]_=7>G\_[WV<59J),<YJ0QX?
     21MV'/RQL7@B;UI\@V<V":7.)ILD6]ZL\EG$RE8\C'YQ,%E.^L)2I'\Q9`=Y9A#
     22MX$"!G3&F*3NBPY`B()79LJ/(.1CFS,[:)N7@.1/#^#E8AQ9,3L8%;WRR=J8`
     23MC$:9H@V$>Q-:,<V&&&E'Y*(TD=GXKA<EM!M#8@`[3EIY%R);@PYRBB[DF4H8
     24M"^<R-$'W)IE,-GK#P:9DS-NNDV?VR22;LPO6>NO0/O-,:V(;<O8^D+6$H@B[
     25M!@O%/6IWO5'+)8)A'#M/,"(,D#D9S]%/FC=(Y!(7OEMO3R]/EF>3Z[-XH+][
     26M]:([48O'N-9Y?S#/Y7+_=KH/SO;73Q?+[9I>;?^T?O=JN]X.U#NTB&3^WB\0
     27MP"P6?_Z/Y?M?MF]6\\X1H_SWBXL7YMY?JYSN[S'/>G2F]G@F/;Z?>G3\A!X=
     28M='Q_^N$#0N[5N]5V=3XU,XNI';33>')+ZZ59;0Y6R]UJO[I<_>U*:.[P1*BA
     29MMUDO-SS2P<L=CY=DQDN6@'Z0C+TM.=:L]F'LF7]S9FHH/O?#RJ4NVF*]T.C>
     30MR-.*O4=\ST;B>FNV#O_3UO'6N:TG!/B>QR21.8J3PT,M^7&;X7"S!X9Q3IB/
     31MUM_F/O--]VF[-'D>8EY]4'OSD.Y?&UYZZC:@;S8".$\*X[>;PLNT>_7B5#QY
     32MQ0+OP[`<-W[8N($W=F0@J90@W^+"XM3N+2JA&%48OY&1B?H")2T8)(/1,+^9
     33ML`C@H8JDZ&`LP)-3+AVC-AX:_')OM4IM]4IUB+#QX\;UKDN^1PV(-EB5WZ(A
     34MU_79$]^AC]_/-.)]OJF110W(DR>5]@&-XV&%&354R2;IP]2I3*A1*T?)O$7F
     35M@!HSL:W>(EH7$6M_3MKAVF"W"4ON;I_1?%*+Y=)8%U(N]R1FZ5JK7$YTL1O5
     36MN!A&!'*U56TPXQDC8Z0MJBD:+$H?FS!8*&.KWB770C6UY&:<*S-6>:=+'KK\
     37M$#N@GPY%65D@8)&^&QCI:6BD9X,CW<1CAKW2F&#-`/4"VDAJ0VT`@Q0V`1,;
     38MK0=1W4'W(()#F2#:0]0*3+*;.-@LU:U4]ZB/Q`ZD]LGH5>2(`XB`]"*B(AE=
     39MP8.HG#9#JNJ,Z,H/D5'302!)6"Z17Q1C9(P^P*:I:"?W2)M!Y`M2H#-'E+YC
     40MGM"M$X7*3`FPG%,L3>A2:2IT7,WA/A&FX<AJ]V)1P2AQ@24R%"C0+T.GC)MA
     41MEER@HSC$C6)GN:';V,D@C*'A(H@"7#)4"<R\9<%6G7ZJ49UU]PYOD@;#!H]A
     42M6#LC#MRD`8:.8W*X`4DU/HGQ447[5.4(8YVM&(DPUN1EL"5%TR1:V0U.*C[:
     43MN(I9O$C#$#\.D@9-_>BM$72IG21EK3/X"AATD"&]BU$F/(E(5F62'"EL"+H*
     44M"C%G=B)D#'J[$8608D8@9\P52B,9IY)+QY(.R&B@2C+HEL5J+FL%%G4ZMN"F
     45MEFXSH'[S55!H*$BQ!2V;&6!&=:D=)K!IN7.XCCBOEM,Y!3-!?4#%X6=QSH.=
     46M`<F5\<G=`Y5&%4PRB3",@YA,;%,D%4@UY%9,8=X4?!98-5_HKD33I[/XQ&LT
     47MW1<;?:C1]*G0_RD[7@^G_?W!K9\'MZ$%M[`SHMM9]^%1T>TLP@WW1_%A'L6'
     48M%L6?:J^S1<'PJ#!^WFVJ@?66)+">&LI36!VA93^G%F+S?2%VE"7"TW-9:5TG
     49MF7I3B6W1W=FW!=_QWG6D^.SK2#%<#\W/?F!H'N/=H7E,WRLTC_E&:/[U1GBN
     50MT#R9*32/7$,A<N+=)!U2C8*8X#V0=#<DI?!^*6WDM'@=""*>E-112RJGS0NQ
     51M%S\D*>OY0#2+WG,-E="&1B"A^DUI3_Q?"Q[P7.TQ/(46-8EP*EMI`C+U2(.D
     52M5VESP,,DUD<"J^QN'L>+\AHT75=>X_>9^B6$OZ&^+;W=:H`2VM^N_T.A?NYQ
     53M;?7R0]&N1?V1\Q3E.^FC'-"_ET!"TGFL3)Q+B)?#%.=DT7G0`QX3SFPDF2)J
     54MMD8*R)C4HR%R49[G>L`3BW$/$GWP%;X@HU,)`XFVH5.&5,(7&1DMRHTR2!"B
     55MHU*B5QTURW5H.V^PW!_&8@YI(<VI`TLLYJ>P3E5S8O76_&2,AIM9!A=1E3R(
     56M#G/VD&C.'G[4?*&OF3#TK#-&J8:/H?,[GY4X&;U/KT`4C*\L(VOLIP>(:I(!
     57M6ESTW&-(,CI,>N!RI1=E[M@D$1V",QNR&`)V325V9!L41M&DPB'T.&KV1#PH
     58M*QTAC?#T,%B?7%78>YD2F%L5_^4:XV%TBHCV/EJ=(>6(0$M$@(%S,)V>9$.J
     59M98P.$T@XD5,MG$Z:!YG*??.<KD_T6R?QTR:IN(N4E"[(@<O50-%4!).Q0>F!
     60M'A&->PNK2-HP/?F+$H^234HA<[8:;AH="E(;"=I3LCH.<H#P6<21M"&>8@@%
     61M!8"&2B2>*-&<"Q'YMA`A\"L\Z![TI1)H%\?(,2A*V%KAIAE#50":U5<"&\9Z
     62M">@QEJ%C\V[XE">!#ZY,U6RK9BGD)+$XX%%Q:D,`>"&"=]GK.-4<=$EV@NK]
     63M0%.T.A)\24MZ`FV"S5ZXL[&F<1X'(R2E/0$RF"*4C",(M`\=LT'6W$4Y9STT
     64MTH<&BX*C#;$,=&5!<%S=ZX[BQ82F3N`;A;Q'KLC2-D<UZ:`/(>;&@]0/"B(5
     65M.2`ZP78ZE$)QU;JH$04[KM*@H$15!T]38"XU7@W!U"Y1S8L4$*_^57JIWK90
     66M)QF>0;J1TSD52GP7%4KV*A5*[E8JE/QU*I3"O9PDQ1DG2>DN*I3-$SE)IGN[
     67MS3SK-MN[J%#V3^TV-"K$5ZA0CA,5RFFB0CDW*F372_@D8^^B0W!H+6Y^_TVD
     68MAPS=0WKPM'EFT@/'>9WTO/]QI(>,NY/TD'F0\'TEZ2$3;I">KS?",Y$>/%_^
     69MZ?8C:EA6RFN$9@Q)W&Q,6P4>2YXOF1LW0A*-_:[4].5>4TO,G.7\G]FM:-2C
     70M=AU*-`\#->ZA!AS0\&9LAG/E>:ZV&YKIJJE4?9K3D,Y!I*4^"*DTU<F(E@8Y
     71MR!JH'KA5FJK(\WPJ,]J,F1G@.A;FN=SEUYBO*CEC+8BW_RGW//X!D/__'9'_
     72MI3LB91.D+R\(&-HTF,WO7"=S&IWN)Q;IE*M/D[QOE5C9*D%/><B;)$,?$4;C
     73M/B=F*,2FBF(+5`@Q=D`M'+U'Q7+MY<BRNU*.=BSY/)1ZY;*SB[)F7YE$CA["
     74MXJ$):$D:-/4C*[KDW&K*6J?<4#`F?;%NUL1@2]^E9XWI)4_%XH8]T@41(7R-
     75M!KLH4$9D[\&/O*B,%$++BH5KRP!>Z61=7@+F/#<P*LBI1O!E14)4HQF'**/6
     76M642=V>,TL\<^LR>?/'.C7)W`6/VG&$T16!8^U-,6_^FJ-VTUE5]H5BPE6D^F
     77MK1Y<.=B2R>,5'QST3JM;8#G'XJ(GYZ@"W.E+7=>39]Z[>:N&0[[^T.'NNO,=
     78MO(3(7.$E1'0;+R&Z_L83T;U[)42SO1(B?P<O(7KB7@G1O3M#1+.=(6)S!R\A
     79M?N+.$'%[]VEKY[R$>'KS"8'DX70>&B]Q#_$2>3ORUFT:XOXBTH=O8RR<[V,L
     80M]L&WB)X:K5NZSE@^_$#&8OENQF+M]V(LUMU@+%]OA.=B+-9/C*6$;L7/R"IE
     81M\U+36S%77[B!#XIP%[)**@>$%7+0B^:-'+-Z(SW"4^E1+V>$IJXWSQII:SK6
     82MR\L!Y<#EH&D!^=,HCL9W0_'SCR`T):R[9HQ*8JYPF&X.W:BYVR!2_0%[/,1W
     83M^FY"L<LPM\M0[-)84%_0M<99Z5&/>,1P]AM-9RS@BN7KDQ$>,6M4P&5).)H@
     84MJ_9()YX`NP1=DO;>FAZ\!9)`<]"#A#4NZ/Z#TZ7U1](HI4]U2+X'>[+ER9G_
     85ML7S)ACE?^A'3C;YUOCV!8#UAPM$TXTHL9#4FTMTKO0;E<3G7Z%A#13%,S.`]
     86M,D2Y1;WW3S\G&-9PV0DOHYQ,)U)"$_2E0*1S*A6!<=E\D0.7*VFWOR@4Z@8=
     87MP*0;<U5+1R5"UZ.,!,E*.D;"3"R+G$U&UZRM5U4=RQ:`#%=?(;^/<3W2'=#,
     88M']PVT[]J%NO66HBV\(9H"W.(P@9PJ$@NMBM&TTZ3CD9JZ)[[EAKKHM0J(W)E
     89M(XJB##XEW_9Z7$JBJQ[*EI^^>(5#XW4Y1E/(1-+1-C:#'`;*W7;-_\P]3HO4
     90M8\ZYAN(;/%^5A]2]'IFI,IC1,R#MO:F`+!LAN-,*ORC,J7`PZX.^6BH'+E<R
     91M,+GMW),MQ$LW8X'QI.S>&-U9D-T=?6E-7E?C0<X'GVV')JS&ND,9="X8>3<M
     92MEE?0"NTR>J^I9I05`J.VA[8A.KDWQ*S;)=GK/#'3!HXS69<OLA4^9X-LX5E?
     93M-KDKZ^I\J\[R:Z1J3J;*A+1E0G*YDHM&L8K[L&-WI+:X$SMC66K_7)V'4^><
     94MKQ(I.TXTRVYF;&J\Q=%.!.H6_B1ORMWD3#;>Q9GDTXLY9[+Y5L[DS'7.Y.[=
     95M5"$WVU2!E[B+,[DG;JJ0NW<+B5R<=YONXDS^B5M()-\0%,[DKG`F>8V_GT-+
     96ML=''Z6L2DO<)E3M=2.`,GG,)UK0#9YHUX>L7Q%M:,P`S1`#9#1;II9UJA5:+
     97MUX0BOL1(7Z:I/+9RNW:[O1]8*V&*THXF]N2G[T'66UIM>;6=]7$OM0KW4JM'
     98M<XG0^=39]+4Y_(A\;QZ4*&RS?$1.M-V2W9*3S\W)2PD%4`B*(`SI4&@$Y?$0
     99M?W!&A6(PH^[(LC8T'G*\A4_X&WS"]3D2,)3O3C^\79ZM!"FT,OV_T>J!5[0:
     100M>3722OZ3'$G'=BHGO3%[Q\?4%-S#'U,_WIB^&Y.^MS67KW^"UWO@,]Y[#1R:
     101M@>DY+'SW"XL4.LK/^#G,4FQB#Y@/QVTQ"2P"6QUR.N1\:,VAI4/+A]8>6O<,
     102MELK-4OP,EHIF\E'RNNWY]2\%2=ZN/?_]X]N3B\6.5CN>"NK"V$=XVX]_6I^_
     103M^KC^./.V<;XP%N'*=[3^<+(Y/OIT\BM&^9>/;V9]P#/O>%;,5XLSG.>ORQTM
     104M_F6->KV+1+,N$CSL'_Y5_O[0;TSH5MM:[^BEGDQ%Z%*E`&]XJ2=3498'0+W(
     105M5.N-5^^7=P'T0\./;U9GLZ>'O`D@^:0%LWQ=`%3Y7HP^[/U.R,(>3GV(?)DQ
     106MV1<O7Z*GQ>EV<?YIL?VR.3_>7!POWFZVI]O^Q#'/7*_($Y.#/'9@=A`HC/).
     107MU&7>_2"9?E2].C8V>\2O^[B3W0WBE,/>[4C>IO'RRM<>S\PDG(*R<?NT(P*7
     108M2\8[,2')1H+QG&!&BM]5OK`CW^2S.TJ3?$:D;0)"C=`%A!ZY";AC?F2_#<#P
     109MFV>8_9@&8/DN0=U1D(MP%LH:R0<)MY<630\1??'`^YV7?"ML#R;1J$0RG'R6
     110M+3E>7F*2-@KB1DI.3"IUO#1&-,1+X2E\F1"A(UN^'V?)0K0LA]V(PPYVITNN
     111M=\I'WV@N(8+VH)ZH%1'U.G3$8AT)>V(PN(BHP>``.'5@/!`)9SO0=<Y16L.@
     112MPXW)_3M]_2Z5!M"9C5P:B*/%:&@#\N$0.VU!)4UJC9VHL-<#6G12D.7%TMH3
     113M))$.TN"=R@%T"3W1UD4!#"_./*13\5GNR;ET,K+Q26[>C3D85^Z6G5/+>G>4
     114M+2G6V[ML7(4C\V:MK_>A(3]8@`51N=N3D^[[%4$"DA?<8I!NQ$36VV"D109K
     115M2^",.CM@4N-U1-$:'B0FBH1AM"FRM8`;&G8-E$8:AG#)N1RS2`KQ@F7Y[%Y:
     116MEE?A@LGB'"D,\WD']FOEC4:C$V]P-CH,A$Z\83;Q!M!)6Z11N)$"]E*+."42
     117MFY"%Y[6`1QW4)(L96A)UK!HLI.6*B]APD>3-6G*EE0#N;G2\T$H>65YG+:W(
     118M"H"OV/`@I:65(A%7\^_8#/+/`K@,>2E`IH1.DH>-T78:7'2(%Z&C3&O"7//R
     119M'K"1YET?#2>RU=$07]!&0QHO@[%#D!)B##[)L`;Q\0BV0\[P_.@GCREY<.S@
     120MM!\P8Y!SRD&0KZ)'&TL_J8T-6ARNN)QA[G*&N<L9)I?31F;'?:D^YSO_^18V
     121MYA[2P:;QK@N:\B;.Q<;6O:D+M[C^;V=MISL0<Y^OPW0]HUSU'VT:3C;_T]Z9
     122M]4J69%GYO7Y%J<5#!EX>LGF@B'[@`8&$>.$Y014WLJ5&G0WJ6TB9ES_/^I:Y
     123M^['C,2BH+@D$64-DA@_'SS';X]IK;SO>WG*M3S]=XLNG2_SX<HE_TK\?XZ-2
     124MV%(N)D3I,_K@GS[Y4_[CY?CLN'_V-DXJ_FG]^7']^;+^_'1\X3ZUZK5^X(W'
     125MH*X4P^<IW!^4EKY6IGPQXXL)7W_XZ3__X_&5+^5<GO"5/(^KOWO-GL)57BM_
     126M\82NQHBN]Y[C]=Z#O-Z__KL?8GOW_OX?O5C?]=N_=;_N#(*/,80ESG>WSZ6X
     127M?RME+IBJ_QSOWH_W_U?]YWK]XLL\57GW0]H6X/_(?[B/_,X+]U>_]`\Y?..J
     128M>CM]^6V]4[[^1>XXO>LLW_F-V\8?Z_W:+6>GC_!:?'=ZZ=N)5>N?%PU'?*C"
     129MUPNH*>8O9=/_+#VYZ\C2D*49/T2NE1CGE/CT^"'M*_.*C+U.#Y'ZZGHBB?,[
     130M)&!)R["V?>GMDQSI;_V?)U6?2]#K]]WGZ1)?EC*]\?E#?%OROODK?^FCOOY0
     131MOJ@ENN3W/:DN\#4]NFO*5R_T;5N)KGS)+HS;>U]XY/L%K[S_V?H>/_=ZTM\K
     132M_[V.ZT,5%=U]015CB)_I8D[MH6_E*R!9BO5+`,YOFOC]__E-$[_O`O]/:N(/
     133M_^E?I?J-,8Q_@:JV(^:&Y_89AI@@LWT)0U1J^2T,,4%L^Y^/O\1O88@IY6]A
     134MB"D9@?R7O'U[Z_I+NOWUZ4+/8.3YW;E=YUN7R7$#"-/V^@TX3&>`,&57NX"#
     135M;'YL/6P6+&W_](W7?_O.;]_Y[3N_?>>W[QROWXUJVT'K&YQS_?C3]>6GZZ>?
     136M+A]_2I<7_?_33TDO9KV:]7+6ZT6O%[U>]'K5ZU6OUQO&_3%=/GZZOGS2Q_2I
     137MZT?]_^43UTLWL/OCBRZG]U^2/I;T,_HI$)U/29_63_&3'_E#;^J3_+K>TFOZ
     138M:=V"?C9SU<R7,]_.?%6OZ79T6_JEPO<+WR]\O_!]O?93U?>KOE]YM=Z@]O:2
     139M/UV;;B;IS_S3M2V0*>F5GR[MH[YZ:9_T.J_\1`<#=W1I+Y_\%^Y,;[$\^H#^
     140MU#?X\'CA'^U3\:6R/I2YH#^[OJ-/\,]4],%T29U'NN3&0^E%/Y:^R</FS/-=
     141M4F3A4^318N(I=8W$!_2./Y'SBU<BZY+Y6BJKH'^P#CP)?]&O^B*L"-_36G!%
     142M_M227#H?JY<<7_A'X?'JK=R@&]?5+_['?7UN3^,;3?QM+12[Y[?\CY?U#^^A
     143M5^IR6RDOR.6V(+=K\$\6A&W0)YN?I[&UC8=9SYW78Z]O>N%O_^2Y+]F;[^?U
     144M-NGSWO^,`&0DH/%PPT_*>M1KNS]G^_%#T<6U>-[&HOV[IK5Q:Y_6;16+WO#N
     145M)/]VXA;3RW%S96U)6;=6O"-K/RR6R=OAV[-TWA7IDHY[*]Z$Q[U1N.%>TEIV
     146MW9ZD92WX)F8QG>4LMR5?Y0ORE<J2+Z^R]Z9X;R0@?3U%#NLQZNTYFI^C1C])
     147M78^R)*N?)"M6GB=6)"OZD6(H?J@:_%3](5KC)EI6JIM$+-7P6B\Y6IOL&^!V
     148M$(B+!>*VVI_O^?1]L.=7]OS*GE]]"]=RWO/YXX>7=J_Z?/RD;=#_ZZ>J[1]:
     149M6.C3-S4+:U.OJ=U6HRV!"VLYDA4MIN';\.(6.*R^DY&X%5V*/5[WD9;PI7*_
     150M$RHQG]J]`I(_LJU9-W*)E1NYWG;ETNO:E?FR#,.2KNDUP"8@9;N`E6H%D(WA
     151MQ[LW92EZ.HM8E'F6#9'09S_YO#WX[;GS)@1+S5!B/[,?.?IW="/Z@?GRD&/_
     152MB"]O<\N3-%]^;=XRLMB#[>JVAY;&A_'2.A_:?)*PLM8S^X<DLX_'66;+"F`E
     153M2=?U1+;B%J2U@DNL;T+D];.9OZ_?>JX+SW7Q<RU1CN%I]6P]_&NW=;N)RVV;
     154M#ANPGFIM4=H>ZFX$RK8YZ7%Y&8"7?%QV+9=7Z_!T+Y^YN\?B2]%^6L(EB9=4
     155MV1\GR;P6QE7/%-G]]&E="SVX.?4EC/=;WC8T+7FY&[1Z/=[15N.&RJYS?J,2
     156M`>@BOI*?\/Z`B9'NB1U\_/QU/?T]7CG&/Z0\WM_*6^5($H])>8EAUU\OCD'!
     157M7,6O#X^7TGM8AN[->O>'?SA*8`R\=CWI[S[\4B^_QGB!WOI+UA]O[?IFMN#Q
     158MX:/?Y\-__=/+?_OXP]]MOUJ_1N"+/RX&%:2J]!HK#*HXC<>L$V.4ZT.I4I;_
     159MRJL-F*Z_2^G*WWEEZ#/Y?CS,<83,`_H@_GLE$GQ=$(F4>J\?^!/W-[>RPO&9
     160M*]6=5#^'\Z[KRPM/\B]?N7SC+U_"@`XL!;`E?@5L^1+0\CGQ*^5',`N]]6OE
     161M"::#?X7L]Y65_]+"WP[;>7]]38D%]X-_>=6]W)\O[/M4MO5[?37$NF#5Z_,:
     162M\><7EOOZ_@33KIH;BWULPO5\H;_B8C]J00Q'_QS(8DCY%X$L)I1_`\BJ&U,M
     163MU?1-(*N6;^%/M7TG_E3''4_ZWO_>O_B-@GP[Z(*IW:=S/M.7__OQ\;3W1V)&
     164MKF_E#_"3K[\<1@T^[-]_)K2%(Z7&E_;MLVU[W#K\V77(T^MQR%-J7R)1Y^/M
     165M9_;T);_UX]TO<:??MF]OQ?M?VN77)I-YO#D?Q\'\'!YVF!&GK_%^WL3KXXBF
     166MU_MA3Y?7=8!3?AS+E.!FOCZ.?;I]F^_<#X"ZWJZ3C\WJZ5OL">B;QZ%3/JLF
     167M/)8__]CNYJ'[)*_.J3&'%;B=W/4Z'YIO3;>BOZ[*2=2G.=]E55`P&\EGA17=
     168MJBO\^L=U55$H:%QO1X"M(UI\$(T_<Z4%E&_=/\JU,]?,/ATF^Z287-[Y>+#,
     169M3^1*S2=S)]EGZ10^?C]P1W]PL<+%"I\I/%:-/G^F^/,UK%-H^%LLW&Z-C]-Y
     170MN+_:USD],IB\T5B.=52/+LWA/=\"V*\^9>:XP=.M^9"GDM?-?-F8Q79U2<IK
     171M^?K\9O^6R?O\^)H6YT,@OEIQV^;;?BY&QXE'/Z?_73&*WR=&EB%$*;[;GGP3
     172M%6V19:FO8^,L1\4BE-F/FPP=7_R*(%ETO/.9SV8^FW7])5JWO^D/OKED*FT;
     173M=Y>I<1.>VU]>;T<[^4=JWK<4V=J_ODNCOX'DE8?0<<$ZOBY92ZJ^?)MW<5HJ
     174M\9?+U%_S$*^6#MEC-D#\X^]^=@LIO-&[*80[^;"+<$COY^[\[*9/SO")T`#[
     175M&'$J,PTYMCQ[K_2MR;9SGDZHI6>Z$'L9,[0V6^_,Q.QS5KV4QXR<J),"9_8,
     176M78SOQ%2KK]J#_%B;^NW[L7G7UEL)NO+(->>A:]>:>YMQSB0'G1D*R7=RJ*V6
     177MV:'F\48HH1<]JSS2G#$'B)53=YS[B+JI03MET&_F&4=C_F`Y%H(9G;W$J2?0
     178MOPW=6YB9X8IQ]C1FCV'64F"I-DB5Q<-38`='9AO.'DH.LW&\D)Y/2Q-'RE57
     179M&&56;JGD'FL)26NTK?B5R8\A]5$8-CEU"U!!1]$5FQ8[UE&U:#%'_12KVYEE
     180MR2ZDH.ME/4/2&C<?TS29$JGU'V5H'4*OK/O4/92LFWG:6H:OILG01_U@Z"F$
     181M4O6,8^2BS8N-%V).VJVI&V1EM5,YI,'=WWWB16%Q2.QB;[&5S(E5(<S"T4^2
     182M"+:X2TB8_=CTR9KT5AS[1J>HG\JAZZY;E;RFJ'4LK41E:D-KI8NTHM^G4Y/S
     183MFJHV;]^T7D+3.UJSD+0'25M74U0.E;.NH%>J5EZRR-4Z0J6-F[O$0X@.,^2I
     184MNQ]ZDEF']K<Q.;3&'@M/IABDECHXFXI62+V@1\B/<Z[T<HPU2SRT7K$T/6?L
     185M"'M$[K5'->NQ)*M%/].:9";VI]U8?&TMN#97ZI5EW-D(2;\VT@=2#5U<MY2B
     186MMJ%*'SHMP1+^SE,59GY&B4[4`T@ZA_Z*F@X$MT@.M3E%BBGQTB:F\':Z?]VS
     187M+JQG1Q-[DKA*Y;36HS1I@YZN*C/24H9L52T-6FNBRY$['75(!B4Q34(BJ2PE
     188M!-T.^JN%BD6+*V.A&]"_(P6;^%SUB$D/(VT.59_L/AAL(GRT[FK!M0H-D;+*
     189M-3TU[-S`T6%\C&72^DH=&A8A5BDM3Q-D$5BF`9=9^]6+;F6W+XQ&E?WJ1?(X
     190M)!FR#4%JA,S4E*0-6C?,`"8K2CMTX5:FC-&867LH`<.R2=\+UE#[(S5+4QO<
     191M6+_D<:ZM>KZ1A&$SMKKA[H/5TFQ2#0E=T^9:"Z6'6HL@^4GHN[XH`U=*87QO
     192MXI"XEB7*,BW<ABZA)1@PB-E<S"OGGTE,UEEEB,)(NYUA"*T>)#+$.*.VV.4)
     193M6;QU74EFG%&S@V/<HG:Z2RDD297><BVYEE]ZP(%KNN7"^*:2)"-55F*$R&Q8
     194M%$`+HG_7C<1-OBYZHNXSW3"HLLH2*9ELB8OVFEF^DKY9&FQI+I8ET-(]74@O
     195M5CU@P+!U)%UB)473523Q,JGT!1341=>4],I>2CB?](HV^,<JZ%X.X[7>;_*%
     196MM6HO,KLFAR+ATI6P^%J1HM5A$*\,<M0=Z7=T=X&%D9GLM#4'J.4R/K*Q14JB
     197M=9=#E+'1!DL#R[#,,_E7U@#UU6;*R+V=-D82U'E#5F)*BYG'&S#<!?>B^Y`A
     198MEARS4/HUZ66@SQ_QKXB_?E*&K4H*M"4R6')PLC#ZUX3[:Y(1.5BM)X?K%591
     199MMWW2?X\_E@`$&:XF(R^+F[7K6@,]5V22[Y!'UZ_J*GA[[F+@@-P:T_2H&761
     200MH9/.2RAJD!Y5/H'YM8^6@Y+$RAY+D+!L4KG=B419$XEA1/;L<3,F#(G1JFHA
     201MH-K+PZ&7LH5RK=("1APW[LO6#S?;[>2Q]%($2=;`6W,/\O0!(R5'PI&(U1[J
     202MY(-H79'Y;P066DH]6+;QUO5D4W3?I?`E&3)9?_UH1\>2C-`H&&+9_2Q#T'-+
     203MK-N4P95`2&3EU66P&-X<Z0M01"$ED\W4<I]L@@R*GE):R'PV]A??VY'+/.D9
     204MD#=E]^5%]+QZ6@Z$E``JSU6$@4H4YD5H1Z(/=93?B\1<EJ`L/Q((162<JO1'
     205MEEI;5'YI]Z?7VDH%,CY*YE<7+#Y=4N)+;)4Q!UI`H@(MN<R4=K'@<?4K"KAT
     206M\\$:&"0MTF/;IX8A"HB+?8&T)`\"FB[SZ##AY(!EC+193*B6$]+.2K]#9_8Y
     207M9IB@#DN3]5/RX%%.V<$GL49%`V2*M9SZ>0FB3(=N(:%.]J$2$>*UR1F/^I+6
     208M7=O`F^WD_["]BO+T#4FVMJUAS`+KX,A"B\KIF=)+60=%"EE.7':!H#?I#C&U
     209M#<%HG&N99=JTF:6A(Q9YW;+L,29??E3>2$N;RY.9ZC]^^+7=%^3M"-6(L.Z2
     210M(DW]Y?&9OADU+C`>%U#^0Z/<P[JX7>P+E\Z/RV5?8?[X078;VR4O-!3-2J<D
     211M<1(-"9)VG&$?,LIR2Q'%D_V5EU:<K+VHQ899SE`KJ]>8E"`+IHUF6YJ#Y,`&
     212M2O5PL(,H"M7NM`>57_K]^0C,AZ0QH"B2AL9_"(Z5+\BC5V),_;!N08N;F(*!
     213M@1PX2>UOY2Q3))^>&?T*_B$C&?I-91THIN('8G_IE?,)^8\1WO;(6.&@-$P!
     214M,%&&OB"AU-\5@^MR4D%=50D+R0NREC!&)$6RM%):SARM#D/DF_`6!.<X%)F@
     215MI,C1B10-19C,R*-T/$JM)W=`CJ6H8^"*`YE%(LXCG$@X`:T7BLQH?_V+)!"3
     216MK85$L1T5R2W*/DIF&<68V2(E0+H'SI=5`B*;BL72<S3=I/[7F,M^#@CEJ;2O
     217M@1A(P3%A'7U-Q#\RO7+>@XQ$8B]%4,1,V,6.=@*9Q%>E;XW1[^R?1(")[W)/
     218MZ`EV0*^C/3+X!%PRT+*YVJYT2BMDYV2%<"$<6K`B!4Z,E>G3%11.R"\-3$[`
     219M:4NII)65L',J:$K$/[*ZDZA<GD\65+9''PTRB@@IB4E"W3%9,H=D!EK3/4#4
     220MFDKV]33*8V1&F]9=EEBWPF/AJ74A!5\2=-T=9J&04\KTR?SBB!6.V9/+[NE^
     221M]#89ZF1RCS94\B5Q(#.48-.Y)?DEJML2FXN6&D^9.`F@88R(,AO)AZZ;'/G+
     222M8G$";K1<*AP@P90U#X1$6&.9/?D);;ZV.F*^*_&:E$;1+Z&DMA[/H8MJ?91&
     223M)_K)-E%D3$K%YLJY:$/POH&XM."OI)1:4%U9#ZC8Q[]-9!#)'*01\D0LD:2D
     224M>47T;Q@#YS\K2(UH0R)$(%@`-U!LMUOF2R%X8CR=A*N3(S<"`"(;_8*DJY!U
     225M#V:ZD$)6LB.ENUI9%H6$'91BN>`1,2@R:J@=]ED2,_`-$B_I-&F-4D=YW?F<
     226M*%/2M[96B]C`G4M<D+E",**X(!(@!ER=8@3E6+\^O.M%WDD;CS@H/@7&B.Q%
     227M`!X`N&@$1QQ'/*>NVTZQJJXL=2,]R8,^0("'1&9,RR*1.\FV1+&3?*7GR!8B
     228M0'[;;N0[(1_3!MX.3_-P)G(8FS/)VQ?3^B*G1DIG9.>81$5&A3&0X6V.;F43
     229M%,Y/TCT0">*-B4U/`14UH('$,+))ID^+HR"P<(('@;W\A9,Z;:$N""BSTMV"
     230M/A/F56U>)H^A[_CA,3FP82@O)U-$;AL1N6XQ.<F120E8"(ZVQHXUP!9.=E&\
     231M7<CF!H$@9VGCO"1*9)8($?Y>MZTXD'TG6,SDF7XV0F%$60$A^J77TMN&5]!?
     232MJK?!1R9/(HG1L[,NVFQR06)JF1H+K:*<0J^J[1`1),=I$],@UKKO2-`DU9>"
     233MH28-(Y@)_RNY.2=GX$91!UD^^=L*]C#JK_L"!9)[MLR_*>.M*%0_@_4E]\>J
     234MR)4H9F6=I43KROJ$_"E^3`NOYV1.E!0T`$0,_HK",WI-47$@8;.IX/3MN/QK
     235M8PVK(;ER2.D5[`;S5(#O4`\P!GZ1)1T$DJAZS`Z7Y7\B9XC@1POZF[@91>`<
     236MRU,(`<GK"6!(CKJE3%FD(MA`G*]@C*A,:B;;2((2W#NK#._7A_C[5/*!I9;]
     237M)K\`9W17M3Z)-9%%K)A9A<R3K91I4WPITSHP$MKG0I"BQXR$4;+F+1#E2'.C
     238M#T*1#DM;@+ILW$@7V>P5T`;9Z#`>\=$5;',ZSL*P!8(T.4$0S4P3.=;=3D_6
     239M/`(8R*!.AH+)Z\DLWN*W`KXH@UB-#>H&I#FX$FV<?E</5QES9_3(X33HH5;!
     240M7](*E%.\=)5&=B!"4H^$M"GLQ]\@P[*P@`O3N6A(F%H6B:`.)+AS.KTN#K(C
     241MXZIU5B!7R1ZDD+IIB9T4:LCR268,:CJ.TX;K4T@V,*6"OM;.`50E7VG.F``T
     242MDR^J36^$@,2'Y#?85-+Q3..UM@$,4)FBGC(PY'+<L&`$#_4#Q=*RD!`F<NH)
     243M"*=_2J00BE9\VXJFB`%J.^776F@2K^!P4F*D)Y9L=,R%UH[D4$N@$$(ZAD^3
     244M8)%;2F)M_)PO2P=03&VCM%#O`^!D'E3!F])>2;CNCZ`1T]M!2"3=I)FRIAFC
     245M<DJW]1@RLX.88AA@3X`GBG8X(0H0&Q.NE25B1$G($$&0P?B51'<08461X#\3
     246M/Q:=.RIOFG@I:00;I"\-L"-\5W=ZB/X-@$%%3WOZC>@61+A*>!1L2TH"B6($
     247MDT+C]5U$70M10;YP,1+&Z#C6J:\2+&H%BG2T%AT)3^PY^(ALA/2%#$77ET3Q
     248M3!+.@FPYG9<F`$:][4F`ED.IB3;)\9-^55D)&(9S].FD5C*BT`=<)X+08.D)
     249MX+163$SE'J6*NAUMPD0M"RE"P(7/:'`^@]%(<XG2.EF`1$#V7B$YV-P.,-NY
     250M%DX\0@L4S8'S,`*29)C59?7QG/P%QZO]Q;^P,5@S/?[#)1+5=0-*%8QA@IA*
     251M]"NAG&(@L/*`A@)Y@E\5SI`".UJS)XY:B4(8O*0\%N&X7)W</:$,T;J"E8IX
     252M*1C(((/$[97L1+:T_;HA#^#R2D0(LF6)NY.*3BZ#&2?G(NO3]A`*$(8&)&^/
     253MD:Z982WLLWZYH=':<"TYBN_1#7J"X=15:Z^;X))*00H+7(X0",`8#RJ!EMP,
     254MYTSXJ006G/WR<"U`JX4V2A&:K53?@JZKTT2$3-L\03')N5".`*R?</PRZ^";
     255MN,=H<%VO>[S,*0)C,$NA;L'RXSJ)#\DOB(")Y0W$@T9IE;@(GAO$QF,D],G.
     256M06(9IRZG(]N'E=7J,+<$^QNQ;I*]HDV3EM3H5)HP)G7C&LZRP6RUZV\/524I
     257MD7/`ATX@4OV%N$-2%_%3NDLY:3(M9!OY!YJGR`<HK$U"1;B;+AGN0)7$O/IE
     258M_0.77"ADV:_7[F$R));$^%FRR(%[6`(CFQ1#HA;MD:P1"[%4BG"TSY4K@I'B
     259M!#O%0ZU;M:Y1TR.5!964,!6@01GV3#G#/RI-)"0%Q00K-^XZ`8>YEM1YVOQD
     260M`$!PJHA9*R!BNE59`8#"3=<N(%<RUF1,'7EQ;89Z*$MC1>6YT99",.MLP!J(
     261M;S#NJ>MB?I(>G-B+JI*V-@--(I;8-FD."U398P5.2,0@I02FQT`3%+:\JR\G
     262MCK%S@5$JO:YHH!N$;P;(N-UF)`R;(Z>(?"G:E#8/`$)`!(I^BH6UF@1@B<00
     263MW%Y"[W`0IXA+(KF2&Y<B-4`<9K*PKC+$VN)Q)!H<3RA)5T)&M"L-UBXZ0Y,;
     264M4!RHW4V`W$A1I.@'W'VK44R769L4G/]JD65'9)'([%A=0-%$S)BIZ5@E,#,\
     265MD_2I8VRJ3;/",UE&%&4S4I%20'+Q:I"*:Z'(6Y#9#!I>*0UF0&.2Z4Z!8("2
     266M:M7T22"4[KI4(:25UD3$KY!0ZCZ"X2J%V(G0N;LLKM_'6>%<P/\EJO;4L]WB
     267M0)<,"!P40\O:!)PMI@2OP>])+*BF2HDD&0,@VD@EJ9,!&RTE83.Q/D4N@`']
     268MC^A07Y)$`G]'8//E6J7"I$I$"H@Y%@?OKPW4\S[EJUIJ`/C(3KD"1PT%M^A9
     269MNE)["1'HL\P&A07$4@_:7??"\%-W7W9W@M<:>:"NBC=7XAS(EW3;I'K&H[43
     270MN@2`(B8''%=K"UY8VV[>FR$ZC(R_K"M)(``".\6,B3'7K\IN23KL`LCT21)C
     271M<L&4R-^%"^K@B=)?9VUTFTQ?HJ(FXZ0-R^!JQ/7DZ7AZ8#K^0EQ`O"L%W1P&
     272MIV!25>]4%?$RLL`\C[Q/I!A+)16H`T_=S70@@::H`X"?@=,5?W!C3<(S6*A)
     273M"B&]2=AUHMAN"%1+C+N"?$%.%\`09"H*)4#75,-X]D%-/HCZP00;09"@"6#T
     274MP=L"SF+@'='J3(I0D'SMMV2(@)IZ,VP(-%G2U,DGAM$Y)XH-<(R$=2H_(M,!
     275MD9LK;BC^/=@4BD\D>J#KTU._'O9>0B@O396.*C%XO\Q@-Y`9S'E0ZHN6@Y;A
     276M0Y%>"!;$IXI&**7QK02;@%*75C)WU]8G@&0!TFJ8U29W1-V(<@8L`M2D&#C3
     277M1W1KTLK=/UYYZA9<6<8C3LHIC418!D\N3L\R*`!3>*5R[M(=]SHP$0";KO]2
     278M!"*VT\\7$!^EB:0;R$D%MW09)<-KH?)5B4=!)66;HQDFU'.H!^TN$L1%42Q(
     279M-'P.GK)1T:V,W48EI%+-`D(1CTA2)D6.4[N`]284TD4+12G]%.%^H-Q7H2/(
     280MOA/0(@5Z9]7W(#Q0RH^&>"RZ""-PG13MY",!0)7*8"2(WX#P`>P8CP7"EPEU
     281M72V7F>\(N@N3Q9CL0%E)PQ.[6EWR;SA\7!LXY33$@@-S$3\3K).E4E/VKL+'
     282M@;,S.;MV]Y%0*@`*$$17&YG@);5CXP.I?!_X.]?5"@P:%(*4'?9.J<:$^58@
     283MV]`N27NLWBBSDH)!.HZA!Q"N5$X26$TD^L1,XB'DJ@(I2MG<)'$QN`;86,1A
     284MW&N<@*G*^2=H=#5&H\==Q*="A76:PD#!(/FM3AZ!G0*:D3-1/,F@<8H*,JP@
     285M)(7RHSP9TEA(P4)Q1D99-MGE;GX2!UBT@\1%Z58I)_PA^Z&6;5A$GH=J'/!=
     286M19,2Q1'6A804=3&WB?S<E6`I"-`WU7FMM]P.J(%6%]3.*;E6@O*.%I[0%JI7
     287M(.8_/&6#53#(^BKQN-;+G\TN#I'+LC#9SY8=3CL=`Z#MI.%@A)UG'J[@DL4K
     288MU*R4["GR2PP&GE?J,^`+Y!40@7V">75\7*14*04^N<KJ)"NA#EJ+AC.59\:O
     289M:<>9&0?2EBG+`L0QV#T09?8E1!U>FZ*#PKTGDM`.T**+1#.P0+0SF@E@#H2#
     290M\RE@W2!6&+R`X0,OH.)_RH0DTQ"]0&W!2;5"PW/O&*!G(T1I*8.7HX^4[1.@
     291M)[%8(8U`\68P-*!H`XC'X_T'N#C<I4!)7.J6R+PSA##V5F(,*J,HB5*5.4LR
     292MHKNO[`0P.;F,(-^#1]5^!QB!`URV#J`M[(R+M\3BLA)@&@-FAAET)*J+[!:]
     293MEY&LFU&5@!4P"BH!-3@42%XB4$H(,KR)/ML@6N:(Z6=?V0&^I<?PK0Q&2[H-
     294MT!8#KI"?.L%H);J1_:K.L*KI8J064"H5Z1`3D[62/(+$2!-DFL;A^0"W0EX)
     295MS2`%2<:J*J50NS=J6<7:#G(!NC%=E[LAZ7A$(Q<PY2;;@N,%VM!:O>W5KPC]
     296M#G,+,0^<DXUG2"5QMP*`1$C=G*1Q6C1B`J4I8>8(@B-QYJ(LZ/I`/F"U&;MS
     297M)&Y@$5)$*JJ-F$6/'U%AV3RY.M9"?^5Z,#41>&206IILGKX",6YB3,B+J%Q#
     298M$03OQ;^EK0APJ6B,F6)$0X2)5DD9X0*98U#"G^8)%L?;<)[T(-`(@9V<N?(*
     299M>&B'B29K"Y>3L95;505<'DBW)Z,T^AKI&,D,'K&X["`A'$M6&_$0+A\5!"N"
     300M\DF%.Y'P:(\(&+6NDKD-K[\DA+*YQIX,27<"9\2=L8^`2Y.%)"V0$<*!8GYQ
     301MJ9THN.#2$0@%B`"Q&2_(+XVRUXHBL#+5+2R2LA5%DSC4:N(5?*T0S$P"4T@8
     302M<-)B/3^RH?6STN.Y)U`^@J>4:55IYH:MR_Q)-Z7]H!H`TV7ED%(B.&^(5UO8
     303MTP3.(.7RR>(<231=PP15Y[QRW5]WL!XQ/:4=E`)0?0AO<,1D<V6/C2)4CG*G
     304M1JGX'$.A/<^F;0Z3><#8,H>E:\]P'08C*+1@L<$UE8_G,W$`LZD,%UXF%0?#
     305M1F@JB+UDG)^7ETX..)B.JXV&%##)#T`!X)CP_X3VXE2H>+7J^N2.;U\R4T4I
     306MM1?R;RRZ'L`T`SV5(7,BQC5]%)*C:YXH"6A/PJE5<Y*)[KK1'KR9'%=Y.`+J
     307MWQ!M3!_UWDB"`\)-C`S#""<(Z9L*Y22:(<EUD3)3$[5#PPW"7(2>U+#Z8,@X
     308MPA/WE/0/S!N]XH84G<`&B-1V*ML-VI;(38%_P7?M>;F+#NED-`><RAP(%2(Y
     309MFKWGCGA3+,'1-!86LAB<4)A:H$ID=)U$54:7&C[!07')!S..!35_&V4KKL`3
     310MB8#J0D`X<TH'82[,U$&]JD67P"D]F30$U],R@!/%'\E/2!L!NP/,7AFNB;\M
     311MV>FL@K]LG"7,$SI]I41&A:Q"J83<W)S(D<G`O-#N`MFZ4@`H9L9<2@YFB'$H
     312M#T%K96<)(PFD48M2GC'G(;]&+19=K,YEX.O`8`)#99.+V8!.=5,;;UN^0>9&
     313M1861N0WR`H9.@10%,P#[107-IN?/W<5QRE*C3HL-90<`]J%3*QR=MMX1LS^=
     314M/)^<%I`&8A8!<AKA%XARLXB!SLD=1DC\#4K&YH4NH+S0Z28*JSN&T@[^G)W3
     315M9(I-'?6I5(=VQS)!6\F,.E1'P"U<RYQ+:F`<=)('[%;8/84M5UX,.C@XD,]@
     316M&7%`D(P(4:XV5/%=,5G^4:Q%E#!C$+,K:0Z`3@*@(5>D_$.M0H\8VU93I1)&
     317M/X8,`8%]'8N="B)/SFA6GJG(P&9YL\_P:&0)2=@4OJ$?P!C3$0U8#05&&5%@
     318MI7`4*>4["%X'E5=\.?1Z61CL/ZST$$UBGD"-'J.]V]#N<=;P)JDVRFS3]R"I
     319MU@80S%9P:@JY4MM3T6^=^*-==](O4<O)_*`(A5\)COZE4651M"S7O=LY:##1
     320M_)42G36#ZI!.`ZR`_"47`(V@GBP7\31P5V<G4:ILCY5-`"^FH`;89Y3?3^4W
     321MN3ML#LT$#/Z&U9VI:A;:.63A,`O30'3(NW@7`XK1F-Y8[#5CZ)VPL9C]3344
     322MD"F<[<4$\(&U"?D!PKB#`R4T'<(UN'&DEH2M?C8!\\</4GL(5]71(O0MB5>$
     323M:R.'!UJC9)3VC&:@.[D,2FH(@NLD'!=#2HAM3&:1(KV@2'I:[`[H@>%=$^Z#
     324MBV-2=!1"=KY13S;/`V#T;0L>$[@FM15*PFP7M(4!F@+;D$H.X52S5$PW*$Q3
     325M](AGH`R&M=Y4&0(53VEJ7JT4TD2\IUQ*IV:A;T$822;2*ECH+B>!>D$*ELR>
     326MP"FMIU853$%/%N&+5]C,U#[H7N+&\"&$SZ!_TAV07F]1BZY'H-\T].C1@,#H
     327M90EP]UQ!(TK5#6L;*1ATTI-)<`?@IXL$9^O3B-*Y>'-M%.,@]@,5R]DP/YQ<
     328MA"GI\AIX1]AS^/9174UT&9F"/D@G;I%R1"9^J?1!A,6/D1P1+6BA%<=%-RL$
     329M^&%`<8-PW!:)!`(VIQS\#DQ="8)`?D'6FOTE1#."!P/!]AAM67O)7;G99?(F
     330M@!UEZGBN!KT;UB6Q82--AN\!V:TORGRF_JX=`Z6GS)^H2!3.E,.(@7T1U,6]
     331M3EK@0,*J,\@;\#S%'%"8V20`V:T`'9LQNX-UKP(T>9R):=H0W<C%0/BIHB>*
     332M2:9Y.)#2);@1H#+VA4P5-!+FB[:[F>BR)P"V=!3XP<\C,240''R4,OP'C/CF
     333MVC0\(<S,I+[*<'G/CD_N/R/+T'I"%U*\05CH-"C`,H)BR"8$[IR"$@Q*H%-"
     334M0;"10&4`)'5NU9L+HN0Z?X6Z$6GT"R`;8.K)A)7(UYHSM\5X`:"@<@T!!YR%
     335MF*;0O@5Z3CF;A>4L`NPA\;)$5B;7"@C&`GVJ$]A0^<@035V]ZV5#I9*[.)()
     336M-D1&5(#A833_$=US8^)5UH6*VW@J'3J^?TINE.XHX)GV'US&1B2JL7=L`J6;
     337M;%02`)5,EK:_Z-X8F51"!QH'^E:_`?Z)/*W"A`AW$8"4,,W4$#-Y:<7BH1!B
     338M*D&1Z!GFA3,^HD3Z@?!N,;GB[AU!M#(]*.;N0ZV,%$Q!B0KL-@C(B<--S#E-
     339M])6=*8?4HJK)MH,2<R#&HU@UH21)V@GA`2_I<E3Z`=63OCKB%T+)YJ,CR%\2
     340MBPCMET`'6>P$480G&&6"NPP"0TXYR33!5P`G"ZD^L1,1_(%+70$A*_4=CBL$
     341M;)#)G'`'BLOJ$!HP8^2L5+'UYLP.2LW.(HJ&T"-%F*ZEXS%,%RF`)PH:*"-0
     342M*QYD,%0_HP,_=KC"!:=$F`$FM.`[+`5PBP-++D-VFR2H+$0NF$+H0)F,5IM+
     343MP2E0@4K%W:ENEW`YSK`0@0O](8K,884E%S4I,>(DZ`C!<Z`BB0X?;3^K0/5^
     344MFE_4TQ,LQ5@>MA#@*KGZJ$C!UG%0(J>[$$X7<%=T?N4Z?>(4$P6!1XM>-3@!
     345MQ%YL!%A/OD)JGO&D$2L7D,'D[LFV3OFX1Q+YW94\#BQ.*02U\&J:9[/[H"(!
     346M-U=B##]0EIN%U,:\G7HL";\-:,`Y-+G!T1:@4`*VYB3*0'6N8"Z`K16Q.&]^
     347M/`AWK*BTW$HYD28#8_S`^!2*:/:`<$6``PT4UK)D\'$/(,?P1`R?X?-@60?*
     348M#63P\E=FH%`ZI>1$+9%.JRTG(D#%,T[J3+0G#=<*M+F0,BA`D9PC3E0+.@VH
     349M<$I.`*#;L:0\U(2A\U.0A$TV[QBVZR)PTEQ6H:)Z2I(HH9(JRR`C#=U=LK37
     350MF2T5W`B5W=4'MZK07-GRGBQAM?HP.XQHCC:+#GPY[!P@U]+5G<!)L-@=@=J3
     351MGRL\3>BC4#GU@/!ID0<27;?L`%@/D*2$;00WCFE'P-R^Y#04)O0D2HQPK%8C
     352MI?LE2&SI70$3@]K((3&/9A<E*%Y<NTMLA&VN&2ORY2"=Q->!FD&@T26;N;3E
     353M4WR'X!2_"AQOGPN*0F(#!8CJ(1I%NC$IA\NP;&G57Z91-^_!_5.T-,.!,@AU
     354M7>_S7'`OIF2`=0RW[$W8`7)(SUTNL"='-ED9(@CT0R>EQ``T%X!14V5SI08Z
     355MJO;X3+.D?$4@29>6J].2"B(,\&@81ER'N+KS^ZR!-GO+O*YT'+=I5TFO(>A\
     356MIV>LF-1>X7I!0JMT`.+#*3V?P",R(FJ:S>41O+@YC?1#0$K+AD'!_C-U5LKT
     357MV+X]%2-RE=11;I>[-X>)ZQ#I0[%N4%D2&,JB,R3H3R?$YR&JV4D^=`EZ0,ER
     358M99F)!0&WR14(RNGM3J?<[`(\HM^=-/OFN;##0JQ&G<7,=]!('BG3(2?[R#D_
     359M.QI(69?42-]TWFLD&YM$NCAA$+.S5-1@;9`$/2=YS&Q+V7<`3H?^)#=A0T+0
     360MVD`#(EVC\#U<Q9.RM,-)T!C`<`.(25!ID]O<J6Y02*>_'G:IRQ]D?]"XY^X@
     361MZ.+']M-'*=?6X7!@DO7(-*-"`R@0+"!<-6*RM\T#(X?PMI*;L<'GS76'0M"`
     362M"TD.R6I@CKBV1Z=1V;P"L#.!3'-(DLV.IO7=DP9`3>F:69E+@:"QIZ`7(A["
     363M?:I"!=K+(+ZBXN<6[E%7>U9VD7_BO`YCGL$E(:SK_L@PB2""[2V)[G"%ME(3
     364MAB?$;N2<]D3S6FB0S=3Z`-(]'B&XJLS\"DH6V#A@IH(1Q<2=TD&*LU2BNXGR
     365M/#Y=XQ`[`%(#!;!.2.SZ)#6-WO:\C?$6`5(!%&`3\J%)3("][BH#O;[D.\[.
     366M*)_M_-%HYH;K#K2R!0K4=+$DX,#$T\"Y&M9=6"VE;;D&K"?<"OPUF""$=90)
     367MPICVBW@&'MF\[4+#^<[GLGV!_^T6SPS!H=+LA7S)ZIFU@05H1.8R*B>^:?$'
     368M)K$7/B_1#9`H2L&BPC=#^F0D"`B[`_2=B<3!W70JP,F_I8A4I@CI=/<1NIX;
     369M1VC#I+\_]ITO=`7])E\EN0/L[(:;`*^P4M%QW&K,-H%VL8T.F^\*!F5L%^8`
     370M7IB<,(A;::?TC!%R@F1>0_)1;W<]L9V@,PBZ)F3?3MT5W%![D3VFQ0T;9.^8
     371M!ZAPU<7ZMZU_")228!OV!50(^"C5I4OP3+SN,$8R'%_!C'@K1\/1%<4"LJKY
     372MYD[@"E`BHFVXF#D#*&-C6#B8+^^-M!ZUH/":NBXL\;HJVF0=>?&LH&#':7O5
     373MW1>Z5^QI*:4+S9P3%KR@D61C$KL*J$3YP7TAE"[TW%M9G0Y)$^-!#YJYBA0R
     374M(?;05YIMVQ2W>MB!XB,.+[T_M7NLW9-#@P21%2DY5`G266PUOV<"2$<;CR\;
     375M467BBJ%XJCXENX15<9C45>G(!7>&=0)5YFS5:>(S%`"A"#8'-G%2L0XT+2T*
     376M".:'C>NAG&UZ=E):B$L2)EG:'F`ST0<-!QTV`O$-_%,#ZR>KG@GI0'\ZLP/@
     377MU3)#15H=C0>8'&$>M5N[1MQM.K&TD_($8D1H`G[<`;7H1*[43)EHY#Z@$L:)
     378MXFP6C1M+8?+-E>UG>"$MNZ1?[?$A@L+[T;_L-"O+)21:3#[DW^`Z%FV9M,-G
     379M)_JL'XBDMN%$RG7UC`DLU!PSL#<^$&VFLX:N/UHI*@4IB'Q/1'A*'V:"U;[<
     380M=7>777?76ES$4ZN.)S*DDUD*4!-(>.@KD.6#:9$=FRW$`9JP:40N/IZ)&;`E
     381M]!/N[*&XAGQPE"?UQ=53:H.8G4#/LM6R2`;ZHA'"^LZ&#Z>3.EK095X*.1#V
     382M#(X-Y=630</>@)S6588!(PDT[0)[T9`\20<E;/1E`L(_F;/\XX?AJ1BPN@V0
     383M40%"HJ'9.^>F,(R!M:;^,A[A2G"#$9\=--L4^)F-80N3D@DM1,YE*)RGS0`J
     384M],<"K7$AU'<<Q<-)`7@B>H=/44%N)#6[[;LDK`3A!QP[>!P`[[K5ZIYVRG\)
     385M-T[2=S)[5W);<IKN\1!@BU2CR5X@^[%H8`*1LE<ZF3SR#/`OXB(J/(:+$40R
     386MQFB>/:_#;YX\Y29/D6(`9:5L>(_F#1JV":>P!8#6'7:+ST"MVT,":,`T<]($
     387M_X"`EX0(TC0Y#4C9,/VT;&;N"O[,>"HT#4(@7=?3X1,MGF[KHO8$26"W<%>*
     388MI\ED4/@+Q)W4'CKX'%-U8$;"$XWKE-%#?AA%/BN[F^CN2T;\Z2Z@:6W15NG/
     389MRT8!=\/&&:A,H8*.TUVV4.@@7:N0?>GJHZ!JYPVG8S-J%WCQU>(RH.-2B2X0
     390M@9V;>:P`-/O"$(]3F$<N1%D,>AJ#A3PAA8:C;K`9Y(N66XK<"T,ZD/EDD@6-
     391M1M@[7`%VE]C+0"!$>Z`7B=VI-:B2^IC^"](>34<W?P:.'X58.L6HR>4S^`@^
     392M"5VK%_-12>!=L&PX"Q=K(.K2@'?FK&&],#TLJ3&]21KB^6=&*Z&C4NZ2/:DG
     393M'P..SIJQPV!*%@2`7P8,,=@LT%II2N38K=:%5AFW$V?`(Z`YQ`%80>I$DQQ$
     394M)$HJ)Z[8U45%ZEAX/?IGTW2ADY2%N)GM&^:@M&=;57[\,+O'4M%(ACFE>`8C
     395MH;I%?E#;T/+=C52&)$T"[WH;T`+T;P_JP2]4#V>9[?9I'!?0.(@<4QHD@9!O
     396MDPL8R!<)&'#%K^V(Y<BQ`BT"V50[N;1,?8H&-QA3Z&/<0[#LZ5>%L1:TLS!6
     397MHE2C:+0U0FJG"-C*]A7\&M.R:,`NGLWE$7^@%A@Z5!TCT<?;:=05*0\4*^94
     398M\!/38\.&V5YP6C)\B[<=BZ"U#YK&)**&($7+`T&F1V9$F^4\'Q8'*2=K8E).
     399M]6`(&.03%U0\EP.6Z?#!QQN&";,3VC'Q-F,?%!R8^<),&&)N6\BP8Y87,OY$
     400M&#;<@H,UA8"UJI-H%.WA)XS2"*A"<Q>]%Q-:9L-]P\9;6>`3:0(^E3MBZ=AA
     401M&$-TN<7P4W3_-M/J=K;$8F)%ST<$AS,ACL[TDMS9W!T+[H,5S3K&"--PN*9)
     402M1L]S6/5NAB>>(#Y0K.3D"G<3S8HC5(<<"BA@$/9$)&.T8%K-<H:!Z4<>-,[C
     403MG6![QB<$#+H=N!U\/MBTP!LT%</N`OQA)\\<@RN8'>+(TR=Z2@C&!B,?,_S\
     404MSJ2'G5MPA:)$4$8?'XTEX`K4;R&71!<728M/D!9E>M3-0]'("4FN5]3FYDIT
     405M-(03G:`[XJ@..`(K#6[BF43`PAVPY339Q/WA<`P'P3FY/L5IR-_:0:D]!>^:
     406MSOVP=/$!!ZQ>>,`V@ATX2!22,6I;:&:3'-S)[*YB*H;0B`)=SEA;8'B%V,\P
     407M5(5&2U<$(ZK6U,#&G;I."Z<<,`Y>,3CZVP,/908E'A63C$VF<0\#P?B;9G"9
     408M&BTLI+>#%@@658P^4N,GR.Q85&:$,#6'\3`+@)28/<CDT-L!/)@2Y5%I-$O"
     409M+J>D!LI,T.[O/ZSP%9B=\`)\%#2_T2#7G0$2M(#1#&YT'*88K"905V0PH6M:
     410MI(O-B-2M6$%%7;^\FV.&(U"Z)0]'WZ.+L![2EN'%,;8/>+J<3/*UVU`7EPL@
     411M[])RUER#A8=,'_["`=/9+',JN@FR4-S,F86'3BLCY"WD#SR]UK-EOM`I"'_;
     412M?9\DL,0)UI)&6]YT_]L*FC>.#G@F'41.Z0`I@]$5@J?H01EQS85L?;/0%S(L
     413MYGI@+^G68B!96,7-N.KOLJTDP"<K?1FT^75;1>6U3*EJ)OU2'^-'W,!288V?
     414MJDON,"+AZ,G\;CA=S(-DZ*+-D5G#RCTW:\U)],K7/>W/12\/>E+`&4Q<]Y`<
     415MZ<$X57"N`$@&^C!#U'N9KP1SF<"7@3L$O-1CZIEI'6TD.C45BK79>.Q<\PG=
     416M@UM@5&+S-J(:LIH,%31&Z4)_)VKU6*=$(P;S&;4BIP*-E9'9$>/6UPWH@B&;
     417M6.]&7VM]YL]>T1]X205N#K$!O#I:<@<<C[*:?DDM%U)P,+],GFB4PBA2H)2&
     418MO\`"22Y-4S%_8Q>I:+8X,WMH"X(1V5;#/I5HFFUIV8*[7LZ3L;);]I3T0/6C
     419M4,M`0N=2F,/HJ@XCR7;1F'P23C?-N\/S4V%+PM1#V@%^TJWYZ,!V&Z,Y*I$Y
     420ML!91DF^*MH)@H@[E>23D9*C!3&!IQL5?AQ($O8L6)`:XZB7&=F'5CA6T[>78
     421M&;.S@,$BG=?,)I%,,R($-K9A:"+HX>[E;NH#!2@:>I"91WF-DBX&S#@NL0(@
     422M!N1[J'7N*'/'(1/3&!<30-89^>C(9,-IXYH[8CB386&,B$45J<(P$*P7)Q1@
     423M8\5ELVC+`+)2F3]ZP,44B'!<`*LVG_15TZL`V&`F!*'%9'ZGR>YD64Z*9)_?
     424M#O-/RRZ37"B34GIF[`)M>^0-TT.EZ<`)IIA!&_$@3RH?`.*_'OX*)T7=W4@I
     425M?"UR8<(=YE@IS(W&SBGT,(J'JD#MGKZC[_UZN#`J#=/L'%B2;;D@!B`QY-'S
     426MA_&S]$C#DL<)=L_J1M+;@670R$AD'8L3YFQN.2M1/!\D`(>X5\(S@"F23FQH
     427M]CS3'=L`NL<L!A,-6YRK'YJV:%J]\9V+#<T.`ILRPFV`^Y`G[%@'P7M<:#HT
     428M2:8>W=C?GB6(;XI4&!FX1@\?(2O#(9\0WRO<3UKQ7#@R0]D429AC'G?JAEB7
     429M;AA5S/013_D@LGN&?YEP:=8RE+3L[M0*&.',U!U;("L@AO#=$`+&("3W1;V=
     430MH38B9!23"C8L0>:W-%/=X0Q`.@!EH0PB+8Z,<()/)-.\`QY@3MEH$V0MMP%U
     431MS[`"!G"9`%H1/+ENHJ@;%N"2G$':"^`',*Z!47?]%0\ERO;A<&MJM%DV'@-[
     432MCDHG&_)4A0-1=\L+00V#\1B0#O4U,)X3^[I8\S.`UP>3,3I!)6V..\X!.X>Z
     433M@,L54,C@9Y':,I*5D+N['9HY+@!E3&.JGHGQA.,V0FQ/X^`I='_)TQ3A9'H<
     434M%AP$>!35%5-&Z='N$CU#:4=!,KJ=,?%@%Q1R/7O22\)*X#8I0IA``=@Y%D:G
     435M!]O!7??J%%OPZGY'INUZ<`$T%+`+1O+`4R*J@4M,0$"0>FZRISB;\YKY`#.)
     436ML@=D5@(6N!:KL`+J/SW5F>FEU>T-;9SD$%729GHR*?,D&7#J,`6^FEG?0!)D
     437M-71P0T>JMLB@<$_U5ZC,#&Z&N(`N$,=`#\L8(3C*'1P_1T^M<3<5X`[&:$=5
     438M[(?ZCQ_HSZ%`T1PN5V.>"K;2P\-<W&4HJT2%4\$I-?-56MV\![>4334Q=9&6
     439M6L5R;SL-8S#5E(:`[A;\XCE)VS56ET?Q>!!0.AB\Y6WC8<"AC,:5FJM=W.9A
     440MGTTHALP%KX*<M]*64+9\@H(Q>`2I776J#IC1CN0!T(89$FQ$\3@:F8A'HJ#O
     441M%\<H%!V"6RH1P'.@3KT'-,?-1'1M10^P.`,F5$/)9[)[.:#5,?;F%(.C:[2L
     442M`0MTYII2Y]P1D0NY,!47&GP9PMSPB.V)QL4R,C!CC821Q8')<J9ID2'0Q4:7
     443M'Q-$2>C+'C73O=7-.V9,.1A,WS%/+PR@$<MJ*CXP<S1M8@,Q/!<6(,+\8'*#
     444M/8B]:D.89TY61,8+$T.*?L80JF=:HW30S3S6]MRJU2%L-!KRR,&Z)YB=$`(F
     445M?3&'DJGI9C2/W)X:I"BW,KO$'9@@2,J\]O4B(V5Z-#Z(2G0_1Y+6JJ'HCJ)O
     446M8_8#QQM0NF!PI@ME@>@8";;T/.9$9H\FO[7%84G3]%D)3/^-UGE,'?5+XV]'
     447M_`]+9@U=ZS3$KH$>'MIO;#YX;@FS%:W^!R6`?NX&;\/CK62`S`!SR==C2*G^
     448MRH_HX>\W2*.BJR&&JNA)0P#II`IK5"N)$OU[,3R^A132GD$.@E+1>`^DT8S<
     449MTO'F*<Z!@4IO1Q1YA=@"8:$;CZ.;`EIO,^>`HC6,CTJQ8H^%8481,]Z:54U<
     450M`P<B8$QFE-#;0BGO:+Z$N<9T40)]-Z01H@X/<&V>N@`ME.`W;$'N59:V3G?5
     451MD),#G%"(8,BDYZ5Z7*;GBXPCHKT0(T*/(%G"?3&%LIG5`0@,><0]X`#\F]D+
     452M).+N]^7$!J@M1H)\"`9@'A1@PJQ8MF@U`K6YC.@3**I'/[HU=:Z]H"+-KQ]E
     453MMHO[Q6U(^"151/AEC+BA4[RZK5?&ZJG,'SW?8GJHKFD=3%-@8+^3EVZ*,V=I
     454MG`,\)HZX>;$Y]$1.%U7).`>E7H^C)X8X5?8Q[31:,AXLN+N76H3#.@\X=/LH
     455MI,M3^%;<,H3`N(]W,LG5V(BG!GN:&TC@4\V)[#:'=4!!,PF".(M<C',W&-X#
     456M&_A<;Z*OQG:CN_L?-DPU.N#&;)H$.#"&YI@]"`/X\B`$!I]#D<##@5'$X#D,
     457M`(X6VZW01,,_L;\$S113".T`!S`3BR=->B#TV(,K<SDII3"J*0(^UC4LA=H+
     458MP`NV(CS-Y6!J7'6W+8>*4&8D2:ENA_*X+FP3M>PGYHZSA.H90AP74$R9#VND
     459M"S,/$;1T+HS3JY-]X!!KU#TV%H8G!3,.BUCHV6:QO4T81X:H4-(H/GPANE>N
     460MNT\2$@A&+;537?![K=^QXC;M-&AY^CQ`9R23-.[Y]EAEXB7WTG!V!S.4Z!IM
     461MN6X?`7$?ZY0-<%*:DJD4:"&.*J([P.&"T+H*Y9AD:S/>U*"XR36@DG!LGIV)
     462M%),):JZG@1["G]K=QA6SFFE]AI-&VK*PEP.+JLZ&AF-T3T');JP[?L!,T>16
     463M`6+SZH.6ME'`W'_LKI5FC]G=375<$Z/=(^T!Y^$$1Z`A'=P`PTI^!TMI-\"1
     464MF?B5X4TTL5'F[QMX<*'=JGG4`@6S:B[#85-S<QLE*`6=,-FPU6$]K\PHH0+"
     465MR((UX$DN8#.4])E2_2;W)_.83YDPXY+Q&)ZCS+E0-8VS_8,HO8;80\:=YWI^
     466M7GR%S-!OVBLY!&`W9PQ?##Z0A4'4'AGSQ`5B]AN]QC"N@P_4.*>/G!SFTY\6
     467MY<3HR<DB87B2#]AI=+XSM.@YWVOH$'S%3JV0M'(O9@>/(0/X:>[\J?EL51!P
     468M?E4:8@/)]=,)3?`L?U(-JM#NP#\Y@L*;=-'2=0WC)9X-PY7*@-NF>W,G'V?V
     469MI'T5F+OF23*@@^;!I<\4/M/5,=U"]Q!=8+FWM-4I&G'HYK&)[M]V9\R,BK<#
     470M`Y)[E+0]T@YMWR_SD.O$9AXX#Z!8W=`:8LFWTU+(@[[MX@'D^6O;:Z?=Z.]F
     471M_O(JR!YKI>RY'BNCMT_6:%-\$_+#.0;0!CZQ]WH["_0)3>$`FG`6V'0C?#R2
     472MT_LQ>N-O?_]S^N/O?D[??XQ>XAB]4TB>.'UM/PCK<JJ%)8X#>WMZZ=LG&26?
     473M9!1/V8=,W)80IZ?KG8X<V</W#3D]GS*2OO>4D2-5YTOR4`_)\[I)@@_#ZE>T
     474ME&_G5_ZR(?3K]/E]]LNUGZ^KA3T-'WM:Q'7:^[EK=M.K'>T\W07V;IM@<*)1
     475M/=^A-FJG<?NU[MO:AB"\G<6%40RG3J)R?JS)][=JS[-PT`NV4_9MK[:6F-HV
     476M:]&V'S^)M:^$V)]8HMMHOKP)\NWCG""Y4X#3'IB\/:T-E+R'5?(+'`%_&*9T
     477M>FH*QB5MA>"ZR7M^$G<J'&GW]V-#Y-]V&YN,0KV=A9@4>IQSXRWTN)X"P/3K
     478MT^6F?WI[[K*'+0\IMUW01ODHAP?8M;6-?I\6W"W5_-O?__T__OGW+R^/DV3'
     479M[0CMEY</\8\O+_\Z\^>'EY?M&.VQ'Z,]TOO?_\=_^X.\SLO+CW_X.1UGTHZR
     480MWDGKG;B]TS@4^Y]^%_Z_^O_]X?MQ>/<8[W__'_[]O_G]W_SY]<_O_^'O/_[-