program swiss;
const
   MAXN = 10000;                        { maximální počet měst }
   MAXM = 1000000;                      { ... a tras }
type
   edge  = record                       { trasa: odkud, kam, délka }
              first, second, value : longint;
           end;
   dedge = record                       { cíl trasy: kam, délka }
              second, value : longint;
           end;
   path  = record                       { nalezené trasy }
              start          : longint; { počáteční město }
              first, second  : longint; { nejdelší trasa }
              fvalue, svalue : longint; { druhá nejdelší }
           end;
var
   m, n  : longint;                     { počet tras a měst }
   P     : array [1..MAXN] of path;     { nalezené trasy }
   edges : array [1..MAXM] of edge;     { trasy v pořadí ze vstupu }
   ec    : longint;
   pos   : array [0..MAXN] of longint;  { trasy z města i jsou uloženy ... }
   out   : array [1..MAXM] of dedge;    { ... v out[pos[i]..pos[i+1]-1] }
   deg   : array [1..MAXN] of longint;  { počet tras z každého města }
   first, second, value : longint;      { pomocné proměnné }
   i, v, w, x, e, f     : longint;
   fin, fout            : text;         { vstupní a výstupní soubor }
   best, a, b, c, d     : longint;  { nejlepší řešení je a-b-c-d-a s hodnotou best }

procedure SetEdge(v, w, value : longint);  { přidá do pole out další trasu }
begin
   out[pos[v]-deg[v]+1].second := w;
   out[pos[v]-deg[v]+1].value := value;
   dec(deg[v]);
end;

begin
   assign(fin,'swiss.in'); reset(fin);          { načítáme vstup }
   assign(fout,'swiss.out'); rewrite(fout);
   readln(fin, n, m);

   for i := 1 to n do deg[i] := 0;              { čteme trasy a počítáme deg[] }
   for i := 1 to m do begin
      readln(fin, edges[i].first, edges[i].second, edges[i].value);
      inc(deg[edges[i].first]);
      inc(deg[edges[i].second]);
      end;

   pos[0] := 0;  { naplánujeme si, kde v out[] budou trasy z kterého města }
   for v := 1 to n do
      pos[v] := pos[v-1] + deg[v];

   for i := 1 to m do begin                     { uložíme trasy do out[] }
      SetEdge(edges[i].first, edges[i].second, edges[i].value);
      SetEdge(edges[i].second, edges[i].first, edges[i].value);
      end;

   best := 0;
   for v := 1 to n do begin                     { projdeme všechna města v }
      for e := pos[v-1]+1 to pos[v] do begin    { a z každého všechny trasy vw }
         w := out[e].second;
         for f := pos[w-1]+1 to pos[w] do begin { a trasy wx navazující na vw }
            x := out[f].second;
            if x = v then continue;             { vrátili jsme se zpět }

            if v <> P[x].start then begin       { inicializace }
               P[x].start := v;
               P[x].fvalue := 0;
               P[x].svalue := 0;
               end;

            if out[e].value + out[f].value > P[x].fvalue then begin
               P[x].second := P[x].first;       { nejlepší dvojice }
               P[x].svalue := P[x].fvalue;
               P[x].first := w;
               P[x].fvalue := out[e].value + out[f].value;
               end
            else if out[e].value + out[f].value > P[x].svalue then begin
               P[x].second := w;                { druhá nejlepší dvojice }
               P[x].svalue := out[e].value + out[f].value;
               end;

            if (P[x].svalue > 0) and (P[x].fvalue + P[x].svalue > best) then begin
               best := P[x].fvalue + P[x].svalue;       { nejlepší čtveřice }
               a := v; b := P[x].first;
               c := x; d := P[x].second;
               end;
            end;
         end;
      end;

   if best = 0 then                             { zapíšeme výstup }
      writeln(fout, 'NEEXISTUJE')
   else begin
      writeln(fout, best);
      writeln(fout, a, ' ', b, ' ', c, ' ', d, ' ', a);
      end;
   close(fout);
end.