program pokeris;
  { 128 u‘davinys }
  const K_SK = 5; { duot— kort— skai‡ius }
        ISL = 8;  { ižložiam— kombinacij— skai‡ius }
        GAL_KOMB = 20; { kei‡iam… kort… galime ižtraukti tiek b–d— }
  type rangas = (dev, des, val, dam, kar, tuz);
       rusis = (cir, bug, kry, vyn);
       korta = record
                 ru: rusis;  { kortos r–žis }
                 ra: rangas { kortos rangas }
               end;
       kortos = array [1..K_SK] of korta;
       islosimai = array [1..ISL] of integer;

  function buvo (kr: kortos; { turimos kortos }
                 i: integer; { kei‡iamos kortos numeris }
                 k: korta { naujai dedamos kortos numeris} ): boolean;
  { tikrina, ar nauja korta nesutampa su kuria nors nekei‡iama korta }
    var j: integer;
  begin
    buvo := false;
    for j := 1 to K_SK do
      if (i <> j) and (k.ru = kr[j].ru) and (k.ra = kr[j].ra)
         then buvo := true
  end; { buvo }

  procedure laimi (kr: kortos; var kiek: islosimai);
  { tikrina, kuri… laimim… situacij… sudaro turima penki— kort— }
  { kombinacija }
    var i: rangas;
        j: rusis;
        ran: array [dev..tuz] of integer;
        rus: array [cir..vyn] of integer;
        galima: array [1..ISL] of boolean;
        { ar galima sudaryti i-t…j… ižložiam… kombinacij… }
        t: integer;
  begin
    for i := dev to tuz do
      ran[i] := 0;
    for j := cir to vyn do
      rus[j] := 0;
    { suskai‡iuosime kiek koki— kort— turime }
    for t := 1 to K_SK do
      begin
        ran[kr[t].ra] := ran[kr[t].ra] + 1;
        rus[kr[t].ru] := rus[kr[t].ru] + 1;
      end;
    for t := 1 to ISL do
      galima[t] := false;
    { tikrinsime pirm…sias keturias kombinacijas }
    for i := dev to tuz do
      if ran[i] = 2
         then if not galima[1]
                 then galima[1] := true { pora }
                 else galima[2] := true { dvi poros }
         else if ran[i] = 3
                 then galima[3] := true { trejetas }
                 else if ran[i] = 4
                         then galima[4] := true; { ketvertas }
    { tikrinsime kombinacij… 'pilni namai' }
    galima[5] := galima[3] and galima[1];
    { tikrinsime kombinacij… 'visos kortos vienos r–žies' }
    galima[6] := false;
    for j := cir to vyn do
      if rus[j] = K_SK
         then galima[6] := true;
    { tikrinsime kombinacij… visos kortos iž eil‚s }
    galima[7] := true;
    for i := dev to tuz do
      if (ran[i] > 1) or (ran[i] = 0) and not (i in [dev, tuz])
         then galima[7] := false;
    { tikrinsime kombinacij… 'pokeris' }
    galima[8] := galima[6] and galima[7];
    { siminsime did‘iausi… sudaryt… kombinacij… }
    t := ISL;
    while (t > 0) and not galima[t] do
      t := t - 1;
    if t > 0
       then kiek[t] := kiek[t] + 1;
  end; { laimi }

  procedure islosimas (kr: kortos;
                       var nr,  { kei‡iamos kortos numeris }
                           komb: integer; { ižložiama kombinacija }
                       var tik: real);
    var kiek: islosimai;
        { kelios kombinacijos sudarys i-t…j… ižložiam… situacij… }
        keic, k: korta;
        kom_sk, { did‘iausias kombinacij— skai‡ius }
        i, j: integer;
  begin
    kom_sk := 0; { nesudar‚me nei vienos ižložiamos kombinacijos }
    for i := 1 to K_SK do
      begin { keisime i-t…j… kort… }
        for j := 1 to ISL do
          kiek[j] := 0;
        keic := kr[i]; { simename kei‡iam… kort… }
        { vietoj kei‡iamos kortos statome visas likusias kortas }
        for k.ru := cir to vyn do
          for k.ra := dev to tuz do
            if not buvo(kr, i, k)
               { jei pakeista korta nedubliuoja kurios nors iž palikt— }
               then begin
                      kr[i] := k;
                      laimi (kr, kiek);
                    end;
        { patikrinsime, gal radome ižložiam… sitacij…, kuri… sudaryti yra }
        { dar didesn‚ tikimyb‚ }
        for j := 1 to ISL do
          if kiek[j] > kom_sk
             then begin
                    kom_sk := kiek[j];
                    nr := i;
                    komb := j;
                  end;
        kr[i] := keic; { atstatome pakeist… kort… }
      end;
    { beliko apkai‡iuoti tikimybŠ }
    tik := kom_sk/GAl_KOMB;
  end; { ižložimas }

  var f: text;
      i, komb, nr: integer;
      tik: real;
      kr: kortos;
      c1, c2: char;
begin
  assign (f, 'POKERIS.DAT');
  reset (f);
  for i := 1 to K_SK do
    begin
      readln (f, c1, c2);
      case c1 of
        '€': kr[i].ru := cir;
        'B': kr[i].ru := bug;
        'K': kr[i].ru := kry;
        'V': kr[i].ru := vyn
     end;
      case c2 of
        '0': kr[i].ra := dev;
        '1': kr[i].ra := des;
        '2': kr[i].ra := val;
        '3': kr[i].ra := dam;
        '4': kr[i].ra := kar;
        '5': kr[i].ra := tuz;
     end;
    end;
  close (f);
  islosimas (kr, nr, komb, tik);
  assign (f, 'POKERIS.REZ');
  rewrite (f);
  case kr[nr].ru of
    cir: write (f, '€');
    bug: write (f, 'B');
    kry: write (f, 'K');
    vyn: write (f, 'V')
  end;
  case kr[nr].ra of
    dev: writeln (f, '0');
    des: writeln (f, '1');
    val: writeln (f, '2');
    dam: writeln (f, '3');
    kar: writeln (f, '4');
    tuz: writeln (f, '5')
  end;
  writeln (f, komb);
  writeln (f, tik: 2: 1);
  close (f);
end.