#include <cstdio>

 #include <iostream>

 #include <algorithm>

 using namespace std;

 int main()

 {

     double sum = 0.65, cnt = ;

     double tmpW, tmpT, tmpL;

     while(cnt--)

     {

         cin >> tmpW >> tmpT >> tmpL;

         if(tmpW > max(tmpT, tmpL))

         {

             cout << "W ";sum *= tmpW;

         }

         else if(tmpT > max(tmpW, tmpL))

         {

             cout << "T "; sum *= tmpT;

         }

         else

         {

             cout << "L "; sum *= tmpL;

         }

     }

     printf("%.2f", (sum-)*);

     return ;

 }

 #include <cstdio>

 #include <iostream>

 #include <vector>

 #include <string>

 #include <unordered_map>

 #include <algorithm>

 #include <functional>

 using namespace std;

 typedef struct NODE

 {

     string id;

     int math, english, cCode, aver;

     NODE(){}

     NODE(int m, int e, int c, int a):math(m),english(e),cCode(c),aver(a){}

 }node;

 vector<int> mathVec, engVec, cCodeVec, averVec;

 unordered_map<string, node> nodeMap;

 unordered_map<string, int> nodeFlagMap;

 void getBestRank(string tmpStr)

 {

     char typeStr[]="ACME";

     int type = , rank = ;

     for(int i = ; i < averVec.size(); ++ i)

     {

         if(averVec[i] == nodeMap[tmpStr].aver)

         {

             rank = i+;

             break;

         }

     }

     for(int i = ; i < cCodeVec.size(); ++ i)

     {

         if(cCodeVec[i] == nodeMap[tmpStr].cCode && i +  < rank)

         {

             type = ;

             rank = i+;

             break;

         }

     }

     for(int i = ; i < mathVec.size(); ++ i)

     {

         if(mathVec[i] == nodeMap[tmpStr].math && i +  < rank)

         {

             type = ;

             rank = i+;

             break;

         }

     }

     for(int i = ; i < engVec.size(); ++ i)

     {

         if(engVec[i] == nodeMap[tmpStr].english && i +  < rank)

         {

             type = ;

             rank = i+;

             break;

         }

     }

     printf("%d %c\n", rank, typeStr[type]);

 }

 int main()

 {

     int N, M;

     cin >> N >> M;

     string tmpId;

     int tmpMath, tmpEng, tmpCode, tmpAver;

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

     {

         cin >> tmpId >> tmpCode >> tmpMath >> tmpEng;

         tmpAver = (tmpMath+tmpEng+tmpCode+1.5)/;

         mathVec.push_back(tmpMath);

         cCodeVec.push_back(tmpCode);

         engVec.push_back(tmpEng);

         averVec.push_back(tmpAver);

         nodeFlagMap[tmpId] = ;

         nodeMap[tmpId] = NODE(tmpMath, tmpEng, tmpCode, tmpAver);

     }

     sort(mathVec.begin(), mathVec.end(), greater<int>());

     sort(cCodeVec.begin(), cCodeVec.end(), greater<int>());

     sort(engVec.begin(), engVec.end(), greater<int>());

     sort(averVec.begin(), averVec.end(), greater<int>());

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

     {

         cin >> tmpId;

         if(nodeFlagMap[tmpId])

             getBestRank(tmpId);

         else

             cout << "N/A" << endl;

     }

     return ;

 }

 #include <cstdio>

 #include <iostream>

 #include <vector>

 #include <cstring>

 #include <cstdlib>

 #include <string>

 #include <unordered_map>

 #include <algorithm>

 #include <functional>

 using namespace std;

 const int INF = 0x7f7f7f7f;

 const int MAXCITY = ;

 #define CLR(a,b) memset(a,b,sizeof(a));

 int routeMap[MAXCITY][MAXCITY];

 int visitFlag[MAXCITY];

 void dfs(int u)

 {

     visitFlag[u] = ;

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

     {

         if(visitFlag[i] ==  && routeMap[u][i] == )

         {

             dfs(i);

         }

     }

 }

 int main()

 {

     int N, M, K;

     cin >> N >> M >> K;

     int tmpSt, tmpEnd;

     CLR(routeMap, 0x7f);

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

     {

         cin >> tmpSt >> tmpEnd;

         routeMap[tmpSt][tmpEnd] = ;

         routeMap[tmpEnd][tmpSt] = ;

     }

     int targetCity;

     for(int j = ; j < K; ++ j)

     {

         cin >> targetCity;

         int cnt = ;

         CLR(visitFlag, );

         visitFlag[targetCity] = ;

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

         {

             if(visitFlag[i] == )

             {

                 cnt++;

                 dfs(i);

             }

         }

         cout << cnt- << endl;

     }

     return ;

 }

 #include <cstdio>

 #include <iostream>

 #include <vector>

 #include <cstring>

 #include <cstdlib>

 #include <string>

 #include <unordered_map>

 #include <algorithm>

 #include <functional>

 #include <queue>

 using namespace std;

 const int INF = 0x7f7f7f7f;

 #define CLR(a,b) memset(a,b,sizeof(a));

 typedef struct WINLINE

 {

     int lastTime, winId;

     queue<int> winQue;

 }winline;

 typedef struct ALLQUE

 {

     vector<int> cusQue;

     int index;

     ALLQUE():index(){}

 }allque;

 const int endTime = *;

 const int startTime = *;

 vector<int> cusTime(, );

 bool cmp(winline a, winline b)

 {

     if(a.winQue.size() != b.winQue.size())

         return a.winQue.size() < b.winQue.size();

     else

         return a.winId < b.winId;

 }

 int main()

 {

     int N, M, K, Q, tmpNum;

     allque allCustQue;

     cin >> N >> M >> K >> Q;

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

     {

         cin >> tmpNum;

         allCustQue.cusQue.push_back(tmpNum);

     }

     vector<winline> winInfo(N);

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

     {

         winInfo[i].lastTime = startTime;

         winInfo[i].winId = i;

     }

     vector<int> tmpQue;

     int maxCap = N*M, nowCap = ;

     for(int t = startTime; t < endTime; ++ t)

     {

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

         {

             while(!winInfo[i].winQue.empty() && winInfo[i].winQue.front() <= t)

             {

                 winInfo[i].winQue.pop();

                 nowCap --;

             }

         }

         while(nowCap < maxCap)

         {

             sort(winInfo.begin(), winInfo.end(), cmp);

             tmpNum = allCustQue.cusQue[allCustQue.index++] + winInfo[].lastTime;

             if(winInfo[].lastTime < endTime)

                 cusTime[allCustQue.index] = tmpNum;

             winInfo[].winQue.push(tmpNum);

             winInfo[].lastTime = tmpNum;

             nowCap ++;

             if(allCustQue.index >= K)

             {

                 t = endTime;

                 break;

             }

         }

     }

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

     {

         cin >> tmpNum;

         if(cusTime[tmpNum] >= startTime)

         {

             tmpNum = cusTime[tmpNum];

             printf("%02d:%02d\n", tmpNum/, tmpNum%);

         }

         else

             cout << "Sorry" << endl;

     }

     return ;

 }