#include <iostream>

 using namespace std;

 struct Node

 {

     int length;

     int price;

 };

 int V, E;

 Node **G;

 void buildGraph();

 void deleteGraph();

 void dijkstra(int s, int d);

 int findMinDist(Node* dist, bool* collected);

 bool cmp(Node a, Node b);

 int main()

 {

     int S, D;

     cin >> V >> E >> S >> D;

     buildGraph();

     dijkstra(S, D);

     deleteGraph();

     return ;

 }

 void buildGraph()

 {

     int a, b, l, p, i;

     G = new Node*[V];

     for (a = ; a < V; a++)

     {

         G[a] = new Node[V];

         for (b = ; b < V; b++)

         {

             G[a][b].length = INT_MAX;

             G[a][b].price = INT_MAX;

         }

     }

     for (i = ; i < E; i++)

     {

         cin >> a >> b >> l >> p;

         G[a][b].length = l;

         G[a][b].price = p;

         G[b][a].length = l;

         G[b][a].price = p;

     }

 }

 void deleteGraph()

 {

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

         delete[] G[i];

     delete[] G;

 }

 bool cmp(Node a, Node b)

 {

     if (a.length != b.length)

         return a.length < b.length;

     else

         return a.price < b.price;

 }

 int findMinDist(Node* dist, bool* collected)

 {

     int minV;

     Node minDist;

     minDist.length = INT_MAX;

     minDist.price = INT_MAX;

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

     {

         if (!collected[i] && cmp(dist[i], minDist))

         {

             minDist = dist[i];

             minV = i;

         }

     }

     if (minDist.length == INT_MAX)

         return -;

     else

         return minV;

 }

 void dijkstra(int s, int d)

 {

     int v, w;

     Node *dist, temp;

     bool *collected;

     dist = new Node[V];

     collected = new bool[V];

     for (v = ; v < V; v++)

     {

         dist[v] = G[s][v];

         collected[v] = false;

     }

     dist[s].length = ;

     dist[s].price = ;

     collected[s] = true;

     while (true)

     {

         v = findMinDist(dist, collected);

         if (v == d) break;

         collected[v] = true;

         for (w = ; w < V; w++)

         {

             if (!collected[w] && G[v][w].length < INT_MAX)

             {

                 temp.length = dist[v].length + G[v][w].length;

                 temp.price = dist[v].price + G[v][w].price;

                 if (cmp(temp, dist[w]))

                     dist[w] = temp;

             }

         }

     }

     cout << dist[d].length << " " << dist[d].price;

     delete dist;

     delete collected;

 }