#include <iostream>

 #include <functional>

 #include <algorithm>

 #define MAX_N 1001

 #define MAX_T 10000000

 using namespace std;

 typedef int Position;

 typedef struct edge_

 {

     int to;

     int cost;

     Position next;

 }Edge;

 typedef struct node_

 {

     Position point;

     Position v;

     int min_cost;

 }Node;

 static Node Gragh_Head[MAX_N];

 static Node Gragh_Head_rev[MAX_N];

 static Edge Gragh_Edge[MAX_N *MAX_N];

 static Edge Gragh_Edge_rev[MAX_N *MAX_N];

 static Node heap[MAX_N];

 static bool used[MAX_N];

 void Search_Dijkstra(const int, const int);

 int Delete_Min(int *const);

 void Insert(Position, Node);

 int main(void)

 {

     int Node_sum, Path_sum, Goal_Farm, tmp_cost, tmp_to, tmp_start;

     while (~scanf("%d%d%d", &Node_sum, &Path_sum, &Goal_Farm))

     {

         for (int i = ; i <= Node_sum; i++)

         {

             Gragh_Head[i].point = -;

             Gragh_Head_rev[i].point = -;

         }

         for (int i = ; i < Path_sum; i++)//邻接表储存

         {

             scanf("%d%d%d", &tmp_to, &tmp_start, &tmp_cost);//起点终点反过来

             Gragh_Edge[i].to = tmp_to;//单向边,因为各个地方的牛要走到#X位置，相当于从#X走到各个点

             Gragh_Edge[i].cost = tmp_cost;

             Gragh_Edge[i].next = Gragh_Head[tmp_start].point;

             Gragh_Head[tmp_start].point = i;

             Gragh_Edge_rev[i].to = tmp_start;//反向边存在另一个图中

             Gragh_Edge_rev[i].cost = tmp_cost;

             Gragh_Edge_rev[i].next = Gragh_Head_rev[tmp_to].point;

             Gragh_Head_rev[tmp_to].point = i;

         }

         Search_Dijkstra(Node_sum, Goal_Farm);

     }

     return ;

 }

 void Insert(Position pos, Node goal)

 {

     Position s = pos, pr;

     for (; s > ; s = pr)

     {

         pr = s %  ==  ? s >>  : (s - ) >> ;

         if (heap[pr].min_cost > goal.min_cost) heap[s] = heap[pr];

         else break;

     }

     heap[s] = goal;

 }

 int Delete_Min(int *const size)

 {

     Position s1, s2, pr = , s;

     Node out = heap[], tmp = heap[(*size)--];

     for (; pr <= *size;)

     {

         s1 = pr << ; s2 = s1 + ;

         if (s2 <= *size)

         {

             s = heap[s1].min_cost < heap[s2].min_cost ? s1 : s2;

             heap[pr] = heap[s];

             pr = s;

         }

         else if (s1 <= *size)

         {

             heap[pr] = heap[s1]; pr = s1;

             break;

         }

         else break;

     }

     Insert(pr, tmp);

     return out.v;

 }

 void Search_Dijkstra(const int Node_sum, const int start)

 {

     int size = ;

     Position V, adj_v;

     memset(used, , sizeof(used));

     for (int i = ; i <= Node_sum; i++)

     {

         Gragh_Head[i].min_cost = MAX_T;

         Gragh_Head[i].v = i;

     }

     Insert(++size, Gragh_Head[start]);

     Gragh_Head[start].min_cost = ;

     while (size != )

     {

         V = Delete_Min(&size);

         used[V] = ;

         for (int k = Gragh_Head[V].point; k != -; k = Gragh_Edge[k].next)

         {

             adj_v = Gragh_Edge[k].to;

             if (Gragh_Head[adj_v].min_cost > Gragh_Head[V].min_cost + Gragh_Edge[k].cost)

             {

                 Gragh_Head[adj_v].min_cost = Gragh_Head[V].min_cost + Gragh_Edge[k].cost;

                 if (!used[adj_v])

                     Insert(++size, Gragh_Head[adj_v]);

             }

         }

     }

     for (int i = ; i <= Node_sum; i++)

     {

         Gragh_Head_rev[i].min_cost = MAX_T;

         Gragh_Head_rev[i].v = i;

     }

     memset(used, , sizeof(used));

     size = ;//堆从0开始，反向边开始

     Insert(++size, Gragh_Head_rev[start]);

     Gragh_Head_rev[start].min_cost = ;

     while (size != )

     {

         V = Delete_Min(&size);

         used[V] = ;

         for (int k = Gragh_Head_rev[V].point; k != -; k = Gragh_Edge_rev[k].next)

         {

             adj_v = Gragh_Edge_rev[k].to;

             if (Gragh_Head_rev[adj_v].min_cost > Gragh_Head_rev[V].min_cost + Gragh_Edge_rev[k].cost)

             {

                 Gragh_Head_rev[adj_v].min_cost = Gragh_Head_rev[V].min_cost + Gragh_Edge_rev[k].cost;

                 if (!used[adj_v])

                     Insert(++size, Gragh_Head_rev[adj_v]);

             }

         }

     }

     int ans = -;

     for (int i = ; i <= Node_sum; i++)

         ans = max(ans, Gragh_Head[i].min_cost + Gragh_Head_rev[i].min_cost);

     printf("%d\n", ans);

 }