rscoeff := proc(f, x, p, a)
    local g, i, j, ng, cg, fs, field, ftable;
    fs := 2^(degree(p));
    field := linalg[vector](fs);
    for i from 1 to fs-1 do
        field[i] := Powmod(a, i, p, a) mod 2:
    od:
    field[fs] := 0;
    ftable := table();
    for i from 1 to fs-1 do
        ftable[ field[i] ] := a^i:
    od:
    ftable[ field[fs] ] := 0;
    g := expand(f) mod 2;
    ng := 0;
    for j from 0 to degree(g,x) do
        cg := coeff(g, x, j):
        cg := ftable[ Rem(numer(cg), p, a) mod 2 ]
              / ftable[ Rem(denom(cg), p, a) mod 2 ];
        if degree(cg,a) < 0 then
           cg := cg * a^(fs-1);
        fi:
        if degree(cg,a) = (fs-1) then
           cg := cg/a^(fs-1);
        fi:
        ng := ng + cg*x^j:
    od:
    g := sort(ng mod 2, x);
    RETURN(g);
end:

rseuclid := proc(t, f, g, z, p, a)
    local q, r, rm1, rp1, um1, u, up1, vm1, v, vp1, i;
    rm1 := sort(Expand(f) mod 2);
    r := sort(Expand(g) mod 2);
    um1 := 1;
    u := 0;
    vm1 := 0;
    v := 1;
    while degree(r,z) >= t do
        rp1 := Rem(rm1, r, z, 'q') mod 2;
        rp1 := rscoeff(rp1, z, p, a);
        q := rscoeff(q, z, p, a);
        vp1 := expand(vm1 - v*q) mod 2;
        vm1 := v;
        v := sort(vp1, z);
        v := rscoeff(v, z, p, a);
        up1 := expand(um1 - u*q) mod 2;
        um1 := u;
        u := sort(up1);
        u := rscoeff(u, z, p, a);
        rm1 := r;
        r := sort(rp1, z);
        print(`Q = `, q, `   R = `, r, 
              `   V = `, v, `   U = `, u);
    od;
    print();
    RETURN(q, r, v, u):
end:

bincoeff := proc(n, bmess)
    local i, j, k, bk, pcoeff, poly;
    pcoeff := []:
    bk := linalg[vectdim](bmess);
    i := 0;
    k := 0;
    while i < bk do
        poly := 0:
        for j from 1 to n do
            poly := poly + bmess[i+j]*a^(j-1):
        od:
        pcoeff := [op(pcoeff), poly]:
        k := k+1;
        i := k*n;
    od:
    RETURN(evalm(pcoeff)):
end:

binmess := proc(cw, n, p, a, ml)
    local i, j, bvect, vs, pco, dga, binmat, binvect;
    for i from 0 to ml do
        pco := coeff(cw, x, i):
        if pco <> 0 then
           dga := degree(pco, a):
           pco := Powmod(a, dga, p, a) mod 2:
        fi:
        vs := []:
        for j from 0 to n-1 do
            vs := [op(vs), coeff(pco, a, j)]:
        od:
        if i = 0 then
           binmat := linalg[matrix](1, n, vs):
        else
           binmat := linalg[stackmatrix](binmat, vs):
        fi:
    od:
    binvect := convert(binmat, vector);
    RETURN(evalm(binvect));
end:

addec := proc(le, re, c, p)
    local i, cle, cre, lambda, res, x3, y3;
    cle := le mod p;
    cre := re mod p;
    if cle = 0 or cre = 0 then
       res := cle + cre;
    elif cle[1] = cre[1] and cle[2] = -cre[2] mod p then
       res := 0;
    else
       if cle[1] = cre[1] mod p and cle[2] = cre[2] mod p
       then
          lambda := ((3*cle[1]^2+c)/2/cle[2]) mod p;
       else
          lambda := (cre[2]-cle[2])/(cre[1]-cle[1]) mod p;
       fi:
       x3 := (lambda^2-cle[1]-cre[1]) mod p;
       y3 := (lambda*(cle[1]-x3)-cle[2]) mod p;
       res := [x3, y3];
    fi:
    res;
end:

elgamal := proc(alpha, e, c, p)
    local calpha, n, y;
    calpha := alpha;
    n := e;
    y := 0;
    while n > 0 do
        if irem(n, 2, 'n') = 1 then
           y := addec(calpha, y, c, p):
        fi:
        calpha := addec(calpha, calpha, c, p):
    od:
    y;
end:

epoints := proc(ec, x, ub, p)
    local ecurve, z, pct, k, i;
    pct := 0;
    for k from 0 to p-1 while pct <= ub do
        z := subs(x=k, ec) mod p;
        if z = 0 then
           pct := pct + 1;
           ecurve[pct] := [k, z];
        fi:
        if z &^ ((p-1)/2) mod p = 1 then
           z := z &^ ((p+1)/4) mod p;
           ecurve[pct+1] := [k, z];
           ecurve[pct+2] := [k, -z mod p];
           pct := pct + 2;
        fi:
    od:
    if pct > ub then
       pct := ub:
    fi:
    seq(ecurve[i], i = 1..pct):
end:

ppoly := proc(pe, vb, n, x, nlist, max)
    local i, j, dcycle, clen, ob10, nb10, res, cyct, vs,
          vc, plist, k, dg, nsum, tmp, m, ct, tmax;
    vs := [];
    vc := [];
    plist := {};
    tmax := max;
    for i from 1 to n do
        vs := [vb[i], op(vs)];
        vc := [vb[i], op(vc)];
    od:
    res := 1;
    dg := 0;
    cyct := 0;
    if linalg[vectdim](pe) = 0 then
       res := res * x[1];
       dg := dg + 1;
    fi:
    if linalg[vectdim](pe) <> 0 then
       ob10 := convert([seq(vs[linalg[vectdim](vs) - ct + 1],
               ct = 1 .. linalg[vectdim](vs))], base, 2, 10);
       if linalg[vectdim](ob10) > 1 then
          m := linalg[vectdim](ob10);
          nsum := 0;
          for i from 1 to m do
              nsum := nsum + ob10[m-i+1]*10^(m-i);
          od:
          ob10 := subsop(1 = nsum, ob10);
       fi:
       if linalg[vectdim](ob10) = 0 then
          res := res*x[1];
          dg := dg+1;
          plist := plist union {0};
       else
          if (member(ob10[1], nlist) = false) and
             (linalg[vectdim](pe) <> 0)
          then
          plist := plist union {ob10[1]};
          nb10 := -1;
          cyct := 0;
          while nb10 <> ob10[1] do
              cyct := cyct + 1;
              for i from 1 to linalg[vectdim](pe) do
                  dcycle := pe[i];
                  clen := linalg[vectdim](dcycle);
                  for j from 1 to clen-1 do
                      vs := 
                      subsop(dcycle[j+1]= vc[dcycle[j]], vs);
                  od;
                  vs := 
                  subsop(dcycle[1] = vc[dcycle[clen]], vs);
                  for k from 1 to n do
                      vc := subsop(k = vs[k], vc);
                  od:
              od:
              plist := plist union {nb10};
              if linalg[vectdim](convert
                  ([seq(vs[linalg[vectdim](vs) - ct + 1],
                      ct = 1 .. linalg[vectdim](vs))],
                      base, 2, 10)) > 1
              then
                 nsum := 0;
                 tmp := convert
                     ([seq(vs[linalg[vectdim](vs) - ct + 1],
                         ct = 1 .. linalg[vectdim](vs))],
                         base, 2, 10);
                 m := linalg[vectdim](tmp);
                 for i from 1 to m do
                     nsum := nsum + tmp[m-i+1]*10^(m-i);
                 od:
                 nb10 := nsum;
              else
                 nb10 := convert
                     ([seq(vs[linalg[vectdim](vs) - ct + 1],
                         ct = 1 .. linalg[vectdim](vs))],
                         base, 2, 10)[1];
              fi:
          od;
          dg := dg + cyct;
          res := res*x[cyct];
          if cyct > tmax then
             tmax := cyct;
          fi:
          fi;
       fi;
    fi;
    RETURN(res, plist, dg, tmax);
end:

switch := proc(n, x, maxsub)
    local vs, i, j, k, pg, bk, nsw, pe, bki, pn, allpoly,
          mon, nlist, dg, vres, colist, pnum, part, pgel,
          jnum, vt, pct, multiplicity, m;
    vs := linalg[vector](n, 0);
    vt := linalg[vector](n, 0);
    nsw := 2^n;
    multiplicity := proc(y, j)
        j[y] := j[y] + 1;
    end:
    allpoly := 0;
    nlist := {};
    pg := []:
    colist := []:
    for pnum from 1 to combinat[numbpart](n) do
        for i from 1 to n do
            j[i] := 0:
        od:
        if pnum = 1 then
           part := combinat[firstpart](n);
        else
           part := combinat[nextpart](part);
        fi:
        map(multiplicity, part, 'j'):
        pgel := [];
        pct := 0;
        for i from 2 to n do
            for jnum from 1 to j[i] do
                pgel := [op(pgel),
                [seq(pct + (jnum-1)*i + k, k = 1..i)]];
            od:
            pct := pct + i*j[i];
        od:
        pg := [op(pg), pgel];
        colist := [op(colist),
        product(1/('k'^j['k']*j['k']!), 'k' = 1..n)];
    od:
    m := 1;
    for i from 1 to nops(pg) do
        pe := pg[i];
        nlist := {};
        mon := 1;
        dg := 0;
        for j from 0 to nsw-1 do
            bk := convert(j, base, 2);
            bki := linalg[vectdim](bk);
            for k from 1 to n do
                vs[k] := 0;
            od:
            for k from 1 to bki do
                vs[k] := bk[k];
            od:
            for k from 1 to linalg[vectdim](vs) do
                vt[linalg[vectdim](vs)-k+1] := vs[k];
            od:
            vres := ppoly(pe, vs, n, x, nlist, m);
            pn := vres[1];
            nlist := nlist union vres[2];
            dg := dg + vres[3];
            m := vres[4];
            mon := simplify(mon*pn);
        od:
        mon := colist[i] * mon * x[1]^(2^n-dg);
        allpoly := simplify(allpoly + mon);
    od:
    maxsub := m;
    RETURN(allpoly);
end:

to_letter := proc(num)
    local cs, cn, sl, a, b, c, d, e, f, g, h, i, j, k,
          l, m, n, o, p, q, r, s, t, u, v, w, x, y, z,
          ltable, ans;
    ltable := table([0=a, 1=b, 2=c, 3=d, 4=e, 5=f, 6=g,
                     7=h, 8=i, 9=j, 10=k, 11=l, 12=m,
                     13=n, 14=o, 15=p, 16=q, 17=r, 18=s,
                     19=t, 20=u, 21=v, 22=w, 23=x, 24=y,
                     25=z]);
    cn := num;
    sl := floor(trunc(evalf(log10(cn)))/2) + 1:
    ans := ``;
    for i from 1 to sl do
        cn := cn/100;
        cs := ltable[frac(cn)*100];
        ans := cat(cs, ans);
        cn := trunc(cn);
    od:
    RETURN(ans);
end:

to_number := proc(mess)
    local sl, cn, sn, ii, ntable;
    ntable := table(['a'=0, 'b'=1, 'c'=2, 'd'=3, 'e'=4,
              'f'=5, 'g'=6, 'h'=7, 'i'=8, 'j'=9, 'k'=10,
              'l'=11, 'm'=12, 'n'=13, 'o'=14, 'p'=15,
              'q'=16, 'r'=17, 's'=18, 't'=19, 'u'=20,
              'v'=21, 'w'=22, 'x'=23, 'y'=24, 'z'=25]):
    sl := length(mess);
    cn := 0;
    for ii from 1 to sl do
        sn := ntable[substring(mess, ii..ii)]:
        cn := 100*cn + sn:
    od:
    RETURN(cn):
end: