program Tunely;
{Dijkstruv algoritmus + pruchod do sírky}

const MaxN = 100;               {maximální pocet mest}

var Vyska: array[1..MaxN, 1..MaxN] of integer;
         {ulození silnic mezi mesty s max. výskami vozidel
         - "matice vzdáleností"}
    H: array[1..MaxN] of integer;       {hodnoty mest}
    Docas: array[1..MaxN] of boolean;   {docasná hodnota pro Dijkstru}
    F: array[1..MaxN] of 1..MaxN;       {fronta pro pruchod do sírky}
    P: array[1..MaxN] of 1..MaxN;       {predchudci mest}
    N: 1..MaxN;                 {pocet mest}
    X, Y: 1..MaxN;              {výchozí a cílové mesto}
    Pruchod: boolean;           {pokracovat v pruchodu}
    V: integer;                 {mozná výska vozidla}
    Z, K: 1..MaxN;              {zacátek a konec fronty v poli F}
    T: text;                    {vstupní data, výsledky}
    i,j: integer;

begin
{Nactení vstupních dat a inicializace polí:}
assign(T, 'tunely.in');
reset(T);
readln(T, N, X, Y);        {pocet mest, výchozí a cílové mesto}
for i:=1 to N do
  begin
  H[i] := 0;
  Docas[i] := true;
  for j:=1 to N do Vyska[i,j] := -1   {silnice i -> j neexistuje}
  end;
readln(T, i, j, V);        {silnice z mesta i do mesta j}
while i <> 0 do            {ctení vstupních dat = silnic}
  begin
  if (V = 0) or ((V > Vyska[i,j]) and (Vyska[i,j] <> 0)) then
    begin                  {zaznamenává se jen "lepsí" silnice}
    Vyska[i,j]:=V;
    Vyska[j,i]:=V;         {silnice je obousmerná}
    end;
  readln(T, i, j, V)       {dalsí silnice}
  end;
close(T);

{Dijkstruv algoritmus pro urcení maximální výsky vozidla:}
H[X] := maxint;            {výchozí mesto bez omezení výsky}
Pruchod := true;
while Docas[Y] and Pruchod do
  begin
  j := Y;     {hledáme mesto s maximální docasnou hodnotou}
  for i:=1 to N do
    if Docas[i] and (H[i] > H[j]) then j := i;
  {vybran vrchol j}
  if H[j] = 0 then
    Pruchod:=false         {mesto Y je nedostupné}
  else
    begin
    Docas[j] := false;     {mesto j bude mít trvalou hodnotu}
    for i:=1 to N do
      if Docas[i] and (Vyska[j,i] >= 0) then
        {mesto i ma docasnou hodnotu a existuje silnice z j do i}
        begin
        V := H[j];    {mozná výska vozidla jedoucího trasou j -> i}
        if (Vyska[j,i] > 0) and (Vyska[j,i] < V) then
          V := Vyska[j,i]; {nutno snízit kvuli omezení silnice}
        if V > H[i] then
          H[i] := V;       {zlepsení - projede sem vyssí vozidlo}
        end
    end
  end;
V := H[Y];                 {výsledná maximální výska vozidla}

{Osetrení prípadu, ze je cílové mesto nedostupné:}
if not Pruchod then
  begin
  assign(T, 'tunely.out');
  rewrite(T);
  writeln(T, -1);          {cílové mesto není dostupné}
  close(T);
  exit
  end;

{Pruchod do sírky - urcení nejkratsí trasy vozidla výsky V mezi mesty X a
Y. Uvazují se pouze silnice bez omezení výsky vozidla nebo s omezením >= V.
Pruchod do sírky provádíme od Y k X, abychom pak pri zpetném chodu získali
prímo trasu z X do Y.}
for i:= 1 to N do H[i] := 0;
H[Y] := 1;                 {evidence, kde jsme jiz byli}
Z := 1; K := 1;
F[1] := Y;                 {ve fronte je jen Y}
while H[X] = 0 do          {dokud jsme nedosli do X}
  begin
  i := F[Z]; Z := Z+1;     {vyzvednout z fronty}
  for j:= 1 to N do
    if H[j] = 0 then
      if (Vyska[i,j] = 0) or (Vyska[i,j] >= V) then
        begin
        H[j] := 1;
        P[j] := i;
        K := K+1; F[K] := j     {vlozit do fronty}
        end
  end;

{Vypsání výsledku - zpetný chod po "predchudcích":}
assign(T,'tunely.out');
rewrite(T);
if V = maxint then V := 0; {bez omezení výsky}
writeln(T, V);             {maximální výska vozidla}
i := X;
while i <> Y do
  begin
  write(T, i, ' ');
  i:=P[i]
  end;
writeln(T, Y);
close(T)
end.