#include <bits/stdc++.h>

#define f first
#define s second
#define pb push_back
#define mp make_pair

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;

const int N = 305, inf = 1e9, mod = 998244353;
const ll INF = 1e18;

int n, m, S, T;

ll d[N][N], dd[N][N];
ll dp[N], d_mx[N];


bool good[N];

vector<int> g[N];

int p[N];

int pp(int v) {
    return p[v] == v ? v : p[v] = pp(p[v]);
}

int col[N];

void dfs(int v) {
    if (col[v] == 1) {
        dp[v] = INF;
        return;
    }
    if (col[v] == 2)
        return;
    col[v] = 1;
    dp[v] = 0;
    if (!good[v]) {
        for (auto to: g[v]) {
            dfs(to);
            dp[v] = max(dp[v], dp[to] + d_mx[v]);
        }
    }
    col[v] = 2;
}

void solve() {
    cin >> n >> m;
    cin >> S >> T;
    S--, T--;

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            d[i][j] = INF;

    for (int i = 0; i < m; i++) {
        int v, u, w;
        cin >> v >> u >> w;
        v--, u--;
        d[v][u] = d[u][v] = w;
    }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            dd[i][j] = d[i][j];

    for (int k = 0; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                dd[i][j] = min(dd[i][j], dd[i][k] + dd[k][j]);

    for (int v = 0; v < n; v++) {
        d_mx[v] = -INF;
        for (int u = 0; u < n; u++)
            if (v != u && dd[v][u] < INF)
                d_mx[v] = max(d_mx[v], dd[v][u]);
        for (int u = 0; u < n; u++)
            if (v != u && dd[v][u] == d_mx[v]) {
//                cerr << v << " " << u << " " << d_mx[v] << endl;
                g[v].pb(u);
            }

        int cnt = 0;
        for (int u = 0; u < n; u++)
            if (v != u && d[v][u] < INF)
                cnt++;
        if (cnt == 1)
            good[v] = 1;
    }
    set<pll> st;
    for (int v = 0; v < n; v++) {
        if (good[v])
            dp[v] = 0;
        else
            dp[v] = INF;
        st.insert({dp[v], v});
    }

    if (good[T]) {
        cout << dd[S][T] << "\n";
        return;
    }

    int bridge = -1;
    for (int i = 0; i < n; i++) {
        iota(p, p + n, 0);
        for (int a = 0; a < n; a++) {
            for (int b = 0; b < n; b++) {
                if (d[a][b] == INF)
                    continue;
                if (a == i && b == T)
                    continue;
                if (a == T && b == i)
                    continue;
                p[pp(a)] = pp(b);
            }
        }
        if (pp(T) != pp(S)) {
            bridge = i;
            break;
        }
    }
    iota(p, p + n, 0);
    for (int a = 0; a < n; a++) {
        for (int b = 0; b < n; b++) {
            if (d[a][b] == INF)
                continue;
            if (a == bridge && b == T)
                continue;
            if (a == T && b == bridge)
                continue;
            p[pp(a)] = pp(b);
        }
    }
    vector<int> starts;
    ll mx = -INF;
    for (int u = 0; u < n; u++)
        if (T != u && dd[T][u] < INF && pp(T) == pp(u))
            mx = max(mx, dd[T][u]);
    for (int u = 0; u < n; u++)
        if (T != u && dd[T][u] == mx && pp(T) == pp(u))
            starts.pb(u);

    ll ans = -INF;

    for (auto v: starts) {
        dfs(v);
        ans = max(ans, dp[v]);
    }
    if (ans >= INF) {
        cout << "impossible\n";
        return;
    }
    cout << ans + dd[S][T] + mx << "\n";
}

int main() {
#ifdef DEBUG
    freopen("input.txt", "r", stdin);
#endif
    ios_base::sync_with_stdio(false);
    int t = 1;
//    cin >> t;
    for (int i = 1; i <= t; i++) {
//        cout << "Case #" << i << endl;
        solve();
    }
}