{$A+,B-,D+,E-,F-,G-,I+,L+,N-,O-,P+,Q+,R+,S+,T+,V+,X+}
{$M 65520,0,655360}
program loginis_reiskinys;
  { 106 u‘davinys }
  const max = 200;
        max_ilg = 20; { maksimalus kintamojo vardo ar skai‡iaus ilgis }
  type lentele = array [1..max] of string[max_ilg];
       logines = (ne, ir, arba);
       lyginimo = (lygu, nelygu, daugiau, maziau, dauglygu, mazlygu);
       log_aibe = set of logines;  { logini— operacij— aib‚ }
       lyg_aibe = set of lyginimo; { lyginimo operacij— aib‚ }

  procedure tarp (var s : string);
    { pažalina tarpus iž reižkinio s prad‘ios }
  begin
    while (s[1] = ' ') do
      delete (s, 1, 1);
  end;
  procedure skaicius (s : string; var ilgis : integer);
    { s - reižkinys, prasidedantis skai‡iumi }
    { proced–ra randa jo ilgŤ }
  begin
    ilgis := 2;
    while s[ilgis] in ['0'..'9', '.'] do
     ilgis := ilgis + 1;
     { gal b–t tai dar ne skai‡iaus pabaiga, o realaus skai‡iaus laipnis }
    if s[ilgis] in ['e', 'E']
       then begin
              ilgis := ilgis + 2;
              while s[ilgis] in ['0'..'9'] do
                ilgis := ilgis + 1
            end;
    ilgis := ilgis - 1;
  end;

  procedure kintamasis (s : string; var ilgis : integer);
    { s - reižkinys, prasidedantis kintamuoju }
    { proced–ra randa jo ilgŤ }
  begin
    ilgis := 1;
    while s[ilgis] in ['A'..'Z', 'a'..'z', '0'..'9'] do
      ilgis := ilgis + 1;
    ilgis := ilgis - 1
  end;

  procedure operacija (s : string;  var ilgis : integer;
                       var login : log_aibe; var lygin : lyg_aibe);
    { s - reiskinys, prasidedantis operacija }
    { procedura randa pa‡i… operacij… ir jos ilgŤ }
    var op : lyginimo;
  begin
    case s[1] of
      'N' : begin              { not }
              ilgis := 3;
              login := login + [ne];
            end;
      'A' : begin               { and }
              ilgis := 3;
              login := login + [ir];
            end;
      'O' : begin              { or }
              ilgis := 2;
              login := login + [arba]
            end;
       else  if s[2] in ['>', '=']   { <>, <=, >= }
                 then begin
                       ilgis := 2;
                       if s[1] = '>'
                          then op := dauglygu
                          else if (s[1] = '<') and (s[2] = '>')
                                  then op := nelygu
                                  else op := mazlygu;
                       lygin := lygin + [op];
                      end
                 else begin          { =, <, > }
                        ilgis := 1;
                        if s[1] = '='
                           then op := lygu
                           else if s[1] = '<'
                                   then op := maziau
                                   else op := daugiau;
                         lygin := lygin + [op];
                      end
    end;
  end;

  procedure kiek_skirt (skaic, kintam : lentele;
                        login : log_aibe;
                        lygin : lyg_aibe;
                        var sk, kint, lyg, log : integer);
     { randa skirting— skai‡i—, kintam—j— bei operacij— kiekŤ }
     const epsilon = 0.1e-10; { realieji skai‡iai lyginami tokiu tikslumu }
     var ly : lyginimo;
         lo : logines;
         a, b, kodas, kiek, i, j : integer;
         lygus, real_a, real_b : boolean;
         areal, breal : real;
  begin
    { rasime kiek yra skirting— skai‡i— }
    kiek := 0;
    i := 1;
    while i <= sk do
      begin
        { Ťtraukiame i-t…jŤ skai‡i— }
        kiek := kiek + 1;
        j := i + 1;
        while j <= sk do { randame skai‡ius, sutampan‡ius su i-tuoju }
          begin
            { nustatytsime, ar skai‡iai yra vienod— tip— }
            real_a := (pos('.', skaic[i]) > 0) or
                      (pos('E', skaic[i]) > 0);
            real_b := (pos('.', skaic[j]) > 0) or
                      (pos('E', skaic[j]) > 0);
            lygus := false;
            if real_a and real_b  { jei abu skai‡iai real–s }
               then begin
                      val (skaic[i], areal, kodas);
                      val (skaic[j], breal, kodas);
                      lygus := abs (areal - breal) < epsilon;
                    end
                else if not real_a and not real_b { jei skai‡iai n‚ra real–s }
                        then begin
                               val (skaic[i], a, kodas);
                               val (skaic[j], b, kodas);
                               lygus := a = b;
                             end;
              if lygus { panaikiname j-t…jŤ skai‡i— }
                 then begin { Ť jo viet… perražome paskutinŤjŤ }
                        skaic[j] := skaic[sk];
                        sk := sk - 1;
                      end
                  else j := j + 1;
          end;
        i := i + 1;
      end;
    { rasime skirting— kintam—j— skai‡i— }
    kiek := 0;
     for i := 1 to kint do
       if kintam[i] <> ''  { jei žis kintamasis dar nepriskai‡iuotas }
          then begin
                 kiek := kiek + 1;
                 for j := i + 1 to kint do
                   if kintam[i] = kintam[j]
                      then kintam[j] := '';
               end;
    kint := kiek;
    { rasime skirting— lyginimo operacij— skai‡i— }
    lyg := 0;
    for ly := lygu to mazlygu do
      if ly in lygin
         then lyg := lyg + 1;
    { rasime skirting— logini— operacij— skai‡i— }
    log := 0;
    for lo := ne to arba do
      if lo in login
         then log := log + 1;
  end;

  procedure skaiciuoti (s : string; { pradinis reižkinys }
                        var sk, kint, lyg, log : integer);
     { suskai‡iuoja kiek reižkinyje yra skai‡i—, kintam—j— ir operacij— }
     var i, ilgis : integer;
         skaic, kintam : lentele;
         login : log_aibe;
         lygin : lyg_aibe;
  begin
    { visos ma‘osios raid‚s reižkinyje kei‡iamos did‘iosiomis }
    for i := 1 to length(s) do
      s[i] := upcase (s[i]);
    { skliaustai pakei‡iami tarpais }
    for i := 1 to length(s) do
      if s[i] in ['(', ')']
         then s[i] := ' ';
    tarp (s); { pažalinami tarpai reižkinio priekyje }
    sk := 0;
    kint := 0;
    lygin := [];
    login := [];
    while s <> '?' do  { kol neižnagrin‚jome viso reižkinio }
      begin
        { reižkinys prasid‚s arba skai‡iumi, arba kintamojo vardu }
        if s[1] in ['0'..'9', '-']
           then begin
                  skaicius (s, ilgis);
                  sk := sk + 1;
                  skaic[sk] := copy (s, 1, ilgis);
                end
           else begin
                  kintamasis (s, ilgis);
                  { reikia patikrinti, ar tai tikrai ne operacija not }
                  if copy (s, 1, ilgis) <> 'NOT'
                     then begin
                            kint := kint + 1;
                            kintam[kint] := copy (s, 1, ilgis);
                          end
                     else ilgis := 0
                end;
        { pažaliname t… skai‡i— ar kintam…jŤ }
        delete (s, 1, ilgis);
        tarp (s);
        { jei tai ne reižkinio pabaiga, randame operacij… }
        if s <> '?'
           then begin
                  operacija (s, ilgis, login, lygin);
                  delete (s, 1, ilgis);
                end;
        tarp (s);
      end;
    kiek_skirt (skaic, kintam, login, lygin, sk, kint, lyg, log);
  end;

  var f : text;
      s : string;
      sk, kint, lyg, log : integer;
begin
  assign (f, 'reisk7.dat');
  reset (f);
  readln (f, s);
  close (f);
  skaiciuoti (s, sk, kint, lyg, log);
  assign (f, 'reisk.rez');
  rewrite (f);
  writeln (f, sk, ' ', kint, ' ',lyg, ' ', log);
  close (f);
end.