program brackets(input, output);
   const first = 0; last = 4;
   var n :integer;

   { -------------------------------------------------------------------- }
   { Generate all strings of 'n' pairs of matched parentheses (brackets). }
   { [n] =  "(" [i] ")" [n-i-1], where i=0..n-1 }
   { http://www.allisons.org/ll/AlgDS/Recn/  August 2012}
   procedure brackets(n : integer);

      var count :integer;

      procedure start(procedure p);
      begin count := count+1; write(count:3, ": "); p end;

      procedure finish; begin writeln(".") end;

      procedure b( procedure before(procedure p); { --what precedes }
                   n :integer;
                   procedure after );             { --what follows }

         var i :integer;

         procedure bPlus(procedure q);
            procedure beforeOpen(procedure p);
               procedure openP; begin write("("); p end;
            begin before(openP) end;

            procedure closeQ; begin write(")"); q end;

         begin b(beforeOpen, i, closeQ) end;   { before "(" [i] ")" q }

      begin{b}
         if n = 0 then before( after )         { done }
         else for i := 0 to n-1 do
                 b( bPlus, n-i-1, after )      { bPlus [n-i-1] after }
      end{b};               { i.e., before "(" [i] ")" [n-i-1] after }

   begin count := 0; b(start, n, finish) end;
   { -------------------------------------------------------------------- }

begin{main}
   for n := first to last do
   begin writeln("n=", n:1);
         brackets(n);
         if n=last then write("http://www.allisons.org/ll/AlgDS/Recn/");
         writeln
end end.

{ the program produces...

n=0
  1: .

n=1
  1: ().

n=2
  1: ()().
  2: (()).

n=3
  1: ()()().
  2: ()(()).
  3: (())().
  4: (()()).
  5: ((())).

n=4
  1: ()()()().
  2: ()()(()).
  3: ()(())().
  4: ()(()()).
  5: ()((())).
  6: (())()().
  7: (())(()).
  8: (()())().
  9: ((()))().
 10: (()()()).
 11: (()(())).
 12: ((())()).
 13: ((()())).
 14: (((()))).

}