program nameliai;
{ 136 u‘davinys }
  const MAX_P = 500; { maksimalus pagaliuk— skai‡ius }
  type  pagaliukai = array [1..MAX_P] of integer;
        lentele = array [1..MAX_P] of boolean;

   procedure rikiuoti (n: integer; var p: pagaliukai);
   { surikiuoja pagaliukus ilgi— ma‘‚jimo tvarka }
   { rikiuojama burbuliuko metodu }
      var i, a: integer;
    begin
      i := 1;
      while i < n do
        if p[i] <= p[i + 1]
           then i := i + 1
           else begin  { sukei‡iame i-t…j¨ ir i+1-m…j¨ element… }
                  a := p[i];
                  p[i] := p[i + 1];
                  p[i + 1] := a;
                  if i > 1 then i := i - 1
                           else i := i + 1;
                end
    end; { rikiuoti }

  function min (x, y: integer): integer;
  begin
    if x < y
       then min := x
       else min := y;
  end; { min }

  function max (x, y: integer): integer;
  begin
    if x > y
       then max := x
       else max := y;
  end; { max }

  function trik (a, b, c: integer): boolean;
  { ar galima i˛ atkarp— a, b, c sudaryti trikamp¨ }
  begin
    trik := ((a + b) > c) and ((a + c) > b) and ((b + c) > a)
  end; { trik }

  function namel (n: integer; p: pagaliukai): integer;
    var sien, nam, daug, i: integer;
        s: pagaliukai;
        nau: lentele;

    function konstr (nr, kiek: integer): integer;
    { rekursin‚ funkcija, konstruojanti namelius }
      var viso, pag, i, j: integer;
          laisva, ieskoti: boolean;
    begin
      if nr > sien
      then begin
             if kiek > nam
                then nam := kiek;
             konstr := kiek;
           end
      else begin
             { galime ˛io namelio nekonstruoti }
             viso := konstr(nr+1, kiek);
             { galime konstruoti namel¨ nr }
             { tikriname, ar nesunaudoti sienoms skirti pagaliukai }
             laisva := true;
             pag := s[nr];
             for i := 0 to 3 do
               if nau[pag + i]
                  then laisva := false;
             if not laisva { jei pagaliukai sunaudoti }
                then begin { daugiau nieko negalime padaryti }
                       konstr := viso;
                       exit;
                      end;
             { sunaudosime sienoms skirtus pagaliukus }
             for i := 0 to 3 do
               nau[pag + i] := true;
             { rasime stog… nameliui su numeriu nr }
             ieskoti := (nam < daug) and ((kiek + sien-nr+1) > nam);
             { jei neradome maksimalaus skai‡iaus nameli— ir }
             { galime rasti daugiau nei turime }
             i := 1;
             while (i <= n) and ieskoti do
               begin
                 j := i + 1;
                 while (j <= n) and ieskoti do
                   begin
                     if not nau[i] and not nau[j] and
                        trik (p[i], p[j], p[s[nr]])
                     then begin { radome stog… }
                            nau[i] := true; nau[j] := true;
                            viso := max (viso, konstr(nr+1, kiek+1));
                            nau[i] := false; nau[j] := false;
                            ieskoti := (nam < daug) and
                                       ((kiek + sien-nr) > nam);
                          end;
                     { praleid‘iami vienodo ilgio pagaliukai }
                     while (j <= n-1) and (p[j] = p[j+1]) do
                      j := j + 1;
                     j := j + 1;
                     if p[i] + p[s[nr]] <= p[j]
                     { jei j-tasis pagaliukas jau per ilgas }
                        then j := n + 1;
                   end;
                 i := i + 1;
               end;
             { atstatome buvusias reik˛mes }
             for i := 0 to 3 do
               nau[pag + i] := false;
             konstr := viso
           end;
    end; { konstr }

  begin
    { pagaliukai surikiuojami ilgi— did‚jimo tvarka }
    rikiuoti (n, p);
    { surasime visus galimas nameli— sienas }
    sien := 0;
    for i := 1 to n-3 do
      if p[i] = p[i+3]
         then begin { radome nauj… sien… }
                sien := sien + 1;
                s[sien] := i; { ¨simename viet… }
              end;
    daug := min (sien, n div 6); { daugiau nameli— sudaryti negalima }
    nam := 0; { did‘iausias sukonstruot— nameli— skai‡ius }
    { nei vienas pagaliukas dar nepanaudotas }
    for i := 1 to n do
      nau[i] := false;
    if daug = 0
       then namel := 0
       else namel := konstr(1, 0);
  end; { namel }

  var f: text;
      i, n: integer;
      p: pagaliukai;
begin
  assign (f, 'NAMELIS.DAT');
  reset (f);
  readln (f, n);
  for i := 1 to n do
    readln (f, p[i]);
  close (f);
  assign (f, 'NAMELIS.REZ');
  rewrite (f);
  writeln (f, namel(n, p));
  close (f);
end.