/*

para resolver el ejercicio calculo la distancia mínima desde el nodo inicial hacia todos los demás y
la distancia mínima desde el nodo terminal hacia todos los demás (gracias al grafo inverso)...

después recorro todos los arcos del grafo, y..
si la distancia mínima para llegar a un nodo,
más el costo del arco,
más la distancia mínima para ir del otro nodo al terminal,
es igual a la distancia mínima entre el nodo inicial y el terminal entonces elimino ese arco...

por último calculo de nuevo la distancia mínima entre el nodo inicial y el terminal...

*/

#include <map>
#include <list>
#include <iostream>
#include <fstream>
using namespace std;

#define INFINITO 999999999
#define in cin
//ifstream in("4210.txt");

list<int>::iterator minimo(list<int> & vertices, int costos[])
{   // devuelve un iterador al vértice con menor costo
	list<int>::iterator it = vertices.begin();
	list<int>::iterator min = it;
	for (it++; it != vertices.end(); it++)
		if (costos[*it] < costos[*min])
			min = it;
	return min;
}

void dijkstra(map<int, int> g[], int nodo, int costos[], int cantNodos)
{   // calcula el costo mínimo para llegar todos los vértices desde "n"
	list<int> vertices;

	for (int i = 0; i < cantNodos; i++) {
		costos[i] = INFINITO;
		vertices.push_back(i);
	}
	costos[nodo] = 0;

	while (!vertices.empty()) {
		list<int>::iterator min = minimo(vertices, costos);
		for (map<int, int>::iterator it = g[*min].begin(); it != g[*min].end(); it++)
			if (costos[it->first] > costos[*min] + it->second)
				costos[it->first] = costos[*min] + it->second;
		vertices.erase(min);
	}
}

int main() {

	int n, m, a, b, c, desde, hasta;
	int costos[500], costosInv[500];
	map<int, int> grafo[500], grinv[500];

	while (in >> n >> m && !(n == 0 && m == 0)) {

		in >> desde >> hasta;

		for (int i = 0; i < m; i++) {
			in >> a >> b >> c;
			grafo[a][b] = c;	// armo el grafo con arcos dirigidos
			grinv[b][a] = c;	// tambien genero el grafo inverso
		}

		dijkstra(grafo, desde, costos, n);
		dijkstra(grinv, hasta, costosInv, n);	

		c = costos[hasta];		// costo del shortest path

		for (int i = 0; i < n; i++)
			for (map<int, int>::iterator it = grafo[i].begin(); it != grafo[i].end(); it++)
				if (costos[i] + it->second + costosInv[it->first] == c)
					it->second = INFINITO;	// elimino los arcos que pertenecen al shortest path

		dijkstra(grafo, desde, costos, n);

		c = costos[hasta];		// costo del almost shortest path

		cout << ((c == INFINITO) ? -1 : c) << endl;

		for (int i = 0; i < n; i++) {
			grafo[i].clear();
			grinv[i].clear();
		}
	}
	//getchar();
	return 0;
}