program Bedrijfsgeluk;
type
  byte_row = array[1..5] of byte;

const
  Anja : byte = 1;
  Edwina : byte = 2;
  Hennie : byte = 3;
  Loes : byte = 4;
  Rina : byte = 5;

  Bram : byte = 1;
  Dirk : byte = 2;
  Ferdinant : byte = 3;
  Gerard : byte = 4;
  Leo : byte = 5;

  Elektricien : byte = 1;
  Klant : byte = 2;
  Leverancier : byte = 3;
  Loodgieter : byte = 4;
  Vertegenwoordiger : byte = 5;

  Bakkerij : byte = 1;
  Bank : byte = 2;
  School : byte = 3;
  Verzorgingshuis : byte = 4;
  Warenhuis : byte = 5;

var
  Bezoeker_Werknemer : byte_row;
  Werknemer_Bezoeker : byte_row;
  Beroep_Werknemer : byte_row;
  Werknemer_Beroep : byte_row;
  Beroep_Bezoeker : byte_row;
  Bezoeker_Beroep : byte_row;
  Bedrijf_Werknemer : byte_row;
  Werknemer_Bedrijf : byte_row;

  k1, k2, k3, fac5 : Longint;
  i, partner, bedrijf, beroep : byte;
  goed, fout : boolean;
  uitkomst : text;

{ ****************************************************** }

procedure permut(L : Longint; n : byte; var r : byte_row);
{
*     Permutations of array r[n]
*     --------------------------
*     L = ordinal number (input)
*     n = number of entries in: (input)
*     r = row of permutations (output)
}
var
  h : Longint;
  k,p,q,s,m,t : byte;
begin
{ Init: }
  h:=1;
  for k := 1 to n do begin
    h:=h*k ; r[k]:=k;
  end;
{ Body: }
  for k := 1 to n do
  begin
    p:=n-k+1;
    h:=h div p;
    q:=(((L-1) div h) mod p)+1;
    if q=1 then Continue;
  { Rotate data: }
    s:=r[k+q-1];
    for m:=1 to q-1 do
    begin
      t:=k+q-m;
      r[t]:=r[t-1];
    end;
    r[k]:=s;
  end;
end;

{ **************** }

procedure Oplossing;
type
  string_row = array[1..5] of string;
const
  Werknemer_naam : string_row =
  ('Anja     ',
   'Edwina   ',
   'Hennie   ',
   'Loes     ',
   'Rina     ');
  Bezoeker_naam : string_row =
  ('Bram        ',
   'Dirk        ',
   'Ferdinant   ',
   'Gerard      ',
   'Leo         ');
  Beroep_naam : string_row =
  ('Elektricien         ',
   'Klant               ',
   'Leverancier         ',
   'Loodgieter          ',
   'Vertegenwoordiger   ');
  Bedrijf_naam : string_row =
  ('Bakkerij          ',
   'Bank              ',
   'School            ',
   'Verzorgingshuis   ',
   'Warenhuis         ');

var
  j : byte;

begin
  Writeln(uitkomst);
  for j := 1 to 5 do
    Writeln(uitkomst,
            Werknemer_naam[j],
            Bedrijf_naam[Bedrijf_Werknemer[j]],
            Bezoeker_naam[Bezoeker_Werknemer[j]],
            Beroep_naam[Beroep_Werknemer[j]]);
  Writeln(uitkomst);
end;

{ ************ }

{ MAIN program }

begin
  Assign(uitkomst,'uitkomst.txt');
  Rewrite(uitkomst);

  fac5 := 1*2*3*4*5;

{ Bezoekers en Werknemers }
{ ----------------------- }
  for k1 := 1 to fac5 do
  begin
    permut(k1, 5, Bezoeker_Werknemer);
    for i := 1 to 5 do
      Werknemer_Bezoeker[Bezoeker_Werknemer[i]] := i;

{ 3. Rina valt niet voor Leo of Ferdinant, }

    partner := Bezoeker_Werknemer[Rina];
    goed := not ((partner = Leo) or (partner = Ferdinant));
    if not goed then Continue;

{ .. Anja niet voor Ferdinant. }

    partner := Bezoeker_Werknemer[Anja];
    goed := not (partner = Ferdinant);
    if not goed then Continue;

  { Bedrijven en Werknemers }
  { ----------------------- }
    for k2 := 1 to fac5 do
    begin
      permut(k2, 5, Bedrijf_Werknemer);
      for i := 1 to 5 do
        Werknemer_Bedrijf[Bedrijf_Werknemer[i]] := i;

{ 2. Anja werkt bij een bank. }

      goed := (Bedrijf_Werknemer[Anja] = Bank);
      if not goed then Continue;

{ 1. Bij Loes en de partner van Gerard is het liefde op het eerste gezicht.
     Bij EEn van de twee is dat tijdens het werk in een school. }

      partner := Werknemer_Bezoeker[Gerard];
      goed := (Bedrijf_Werknemer[Loes] = School)
          xor (Bedrijf_Werknemer[partner] = School);
      if not goed then Continue;

{ 2. Dirk komt nooit in een bakkerij of verzorgingshuis. }
      partner := Werknemer_Bezoeker[Dirk];
      goed := (partner <> Werknemer_Bedrijf[Bakkerij])
          and (partner <> Werknemer_Bedrijf[Verzorgingshuis]);
      if not goed then Continue;

{ 2. Leo ontmoet zijn vlam in een warenhuis. }

      partner := Werknemer_Bezoeker[Leo];
      goed := (partner = Werknemer_Bedrijf[Warenhuis]);
      if not goed then Continue;

    { Beroepen en Bezoekers }
    { --------------------- }
      for k3 := 1 to fac5 do
      begin
        permut(k3, 5, Beroep_Werknemer);
        for i := 1 to 5 do
          Werknemer_Beroep[Beroep_Werknemer[i]] := i;
        for i := 1 to 5 do
          Bezoeker_Beroep[i] :=
          Bezoeker_Werknemer[Werknemer_Beroep[i]];
        for i := 1 to 5 do
          Beroep_Bezoeker[Bezoeker_Beroep[i]] := i;

{ 1. De leverancier wordt niet in een verzorgingshuis aan de haak geslagen }

        partner := Bezoeker_Beroep[Leverancier];
        goed := Werknemer_Bezoeker[partner]
             <> Werknemer_Bedrijf[Verzorgingshuis];
        if not goed then Continue;

{ .. en heet niet Bram. }

        goed := partner <> Bram;
        if not goed then Continue;

{ 3. Edwina wordt niet verliefd op een klant of leverancier. }

        partner := Bezoeker_Werknemer[Edwina];
        goed := (Beroep_Bezoeker[partner] <> Klant)
            and (Beroep_Bezoeker[partner] <> Leverancier);
        if not goed then Continue;

{ 4. De elektricien en Bram [ wonen in dezelfde plaats ];
     EEn van beiden is het liefje van Hennie. }

        partner := Bezoeker_Werknemer[Hennie];
        goed := (partner = Bram) xor (partner = Bezoeker_Beroep[Elektricien]);
        if not goed then Continue;

{ 4. Ferdinant is geen elektricien. }

        goed := Beroep_Bezoeker[Ferdinant] <> Elektricien;
        if not goed then Continue;

{ 2. Ze [ Anja ] heeft daar geen ontmoeting met
     de leverancier of de vertegenwoordiger, die Dirk heet. }

        goed :=  Beroep_Bezoeker[Dirk] = Vertegenwoordiger;
        if not goed then Continue;

        partner := Bezoeker_Beroep[Leverancier];
        goed := Werknemer_Bezoeker[partner] <> Anja;
        if not goed then Continue;

        partner := Bezoeker_Beroep[Vertegenwoordiger];
        goed := Werknemer_Bezoeker[partner] <> Anja;
        if not goed then Continue;

        Oplossing;

      end;
    end;
  end;
  Close(uitkomst);
end.