#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

#define MAXN 16384
#define MAXM 65536

struct vert
{
  unsigned num_arcs, na;
  struct arc **arcs;
  unsigned dist;
  char done;
  unsigned heap_idx;
};

static struct vert verts[MAXN];

static struct vert *heap[MAXN];

unsigned heap_size;

void
heap_del_top (void)
{
  struct vert *x;
  unsigned j;

  x = heap[heap_size--];
  j = 1;
  while (2 * j <= heap_size)
    {
      unsigned n;

      n = 2 * j;
      if (n < heap_size)
	if (heap[n + 1]->dist < heap[n]->dist)
	  n++;
      if (x->dist > heap[n]->dist)
	{
	  heap[j] = heap[n];
	  heap[j]->heap_idx = j;
	  j = n;
	}
      else
	break;
    }
  heap[j] = x;
  x->heap_idx = j;
}

void
heap_update (struct vert *v)
{
  unsigned j;

  j = v->heap_idx;
  while (j > 1)
    {
      unsigned p;

      p = j / 2;
      if (v->dist < heap[p]->dist)
	{
	  heap[j] = heap[p];
	  heap[j]->heap_idx = j;
	  j = p;
	}
      else
	break;
    }
  heap[j] = v;
  heap[j]->heap_idx = j;
}

struct arc
{
  unsigned f, t, v;
} arcs[MAXM];

int
main (void)
{
  for (;;)
    {
      unsigned n, m, s, c;
      struct vert *v;
      struct arc *a;

      scanf ("%u%u%u%u", &n, &m, &s, &c);
      if (n == 0 && m == 0 && s == 0 && c == 0)
	break;
      s--;
      c--;
      for (a = arcs; a < arcs + m; a++)
	{
	  scanf ("%u%u%u", &a->f, &a->t, &a->v);
	  a->f--;
	  a->t--;
	  verts[a->f].na++;
	}
      heap_size = n;
      for (v = verts; v < verts + n; v++)
	{
	  v->arcs = realloc (v->arcs, sizeof (*v->arcs) * v->na);
	  v->dist = UINT_MAX;
	  v->num_arcs = 0;
	  v->done = 0;
	  v->heap_idx = v - verts + 1;
	  heap[v->heap_idx] = v;
	}
      for (a = arcs; a < arcs + m; a++)
	{
	  v = verts + a->f;
	  v->arcs[v->num_arcs++] = a;
	}
      verts[s].dist = 0;
      if (s != 0)
	{
	  heap[1]->heap_idx = s + 1;
	  verts[s].heap_idx = 1;
	  heap[s + 1] = heap[1];
	  heap[1] = verts + s;
	}
      while (verts[c].done == 0)
	{
	  struct arc **ap;

	  v = heap[1];
	  heap_del_top ();
	  v->done = 1;
	  for (ap = v->arcs; ap < v->arcs + v->num_arcs; ap++)
	    {
	      struct vert *v2;
	      unsigned val;

	      v2 = verts + (*ap)->t;
	      val = (*ap)->v + v->dist;
	      if (v2->dist > val)
		{
		  v2->dist = val;
		  heap_update (v2);
		}
	    }
	}
      printf ("%u\n", verts[c].dist);
    }
  return EXIT_SUCCESS;
}