#include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>
#include <utility>
#include <cstdlib>
#include <cmath>
#include <string>

using namespace std;


class Sortuj_X;
class Sortuj_Y;
class Punkt
{
public:
    string nazwa;
    double stopnie_szerokosc;
    double stopnie_dlugosc;


    /*void stworz(string nazwa,
    int stopnie_szerokosc,
    int minuty_szerokosc,
    string PLN_PLD,
    int stopnie_dlugosc,
    int minuty_dlugosc,
    string WSCH_ZACH)*/
    void stworz(){
        int minuty_szerokosc;
        string PLN_PLD;
        int minuty_dlugosc;
        string WSCH_ZACH;
        cin >> nazwa >> stopnie_szerokosc >> minuty_szerokosc >> PLN_PLD >> stopnie_dlugosc >> minuty_dlugosc >> WSCH_ZACH;

        stopnie_szerokosc = stopnie_szerokosc + (minuty_szerokosc/60.0f);
        stopnie_dlugosc = stopnie_dlugosc + (minuty_dlugosc/60.0f);
        stopnie_szerokosc = stopnie_szerokosc * M_PI/180.0f;
        stopnie_dlugosc = stopnie_dlugosc * M_PI/180.0f;
        if(PLN_PLD == "S")
            stopnie_dlugosc *= -1;

        if(WSCH_ZACH =="W")
            stopnie_szerokosc *= -1;
    }



};
double obwod_sfery;
const double _PI = 3.14;
double _krzywa = (40075,704/360);
const double _pol = 180;
Punkt *temp = new Punkt;
double najmniejszy = INFINITY;
double promien = (M_PI+M_PI);

class Sortuj_X
{
public:
    bool operator()(Punkt const &a, Punkt const &b)
    {
        return a.stopnie_szerokosc < b.stopnie_szerokosc;
    }

};

class Sortuj_Y
{
public:
    bool operator()(Punkt const &a, Punkt const &b)
    {
        return a.stopnie_dlugosc < b.stopnie_dlugosc;
    }

};




double  znajdzOrtodromadlaTab(Punkt x, Punkt y)
 {
     double ortodroma;



    //ortodroma =  sqrt(pow(y.stopnie_szerokosc - x.stopnie_szerokosc, 2) + pow((cos((x.stopnie_szerokosc * _PI)) / _pol) * (y.stopnie_dlugosc - x.stopnie_dlugosc), 2))* _krzywa;
    //ortodroma = acos( (sin(szerokosc_D1) * sin(szerokosc_D2)));//  + ( cos(pkt[i].stopnie_szerokosc) * cos(pkt[i+1].stopnie_szerokosc) * cos(pkt[i].stopnie_dlugosc - pkt[i+1].stopnie_dlugosc)  ) ) ;
    ortodroma = acos(   (sin(x.stopnie_szerokosc) * (sin(y.stopnie_szerokosc))) + (cos(x.stopnie_szerokosc) * cos(y.stopnie_szerokosc) * cos(x.stopnie_dlugosc - y.stopnie_dlugosc)  ) )   *promien;

            return   ortodroma;
 }



 void zamien(Punkt *tab, int i, int j)
 {

     temp = &tab[i];
     tab[i] = tab[j];
     tab[j] = *temp;


 }

pair<Punkt, Punkt> punkty;

 double dlaPojedynczych(Punkt *tab, int rozmiar)
 {
      // DUZA LICZBA
     for(int i =0; i<rozmiar; ++i)
     {
         for(int j=i+1; j<rozmiar; ++j)
         {


            if(znajdzOrtodromadlaTab(tab[i], tab[j]) < najmniejszy)
         {
             najmniejszy = znajdzOrtodromadlaTab(tab[i], tab[j]);

             punkty = make_pair(tab[i], tab[j]);
         }
         }
     }

     return najmniejszy;
 }

 double minFunkcja(double x, double y)
 {
     if(x < y)
        return x;
     if(y < x)
        return y;
 }

double funkcjaRoznica(double a, double b)
{
    double roznica;
    roznica = a-b;
    return roznica;
}

 double punktyPasek(Punkt *pasek, int rozmiar, double odleglosc)
 {
    najmniejszy = odleglosc;
     sort(pasek , pasek+rozmiar, Sortuj_Y() );

     for(int i = 0; i < rozmiar; ++i){

        for(int j = i+1; j < rozmiar && (funkcjaRoznica(pasek[j].stopnie_dlugosc, pasek[i].stopnie_dlugosc)  ) < najmniejszy; ++j)
        {
            if(znajdzOrtodromadlaTab(pasek[i], pasek[j])< najmniejszy)
            {
                najmniejszy = znajdzOrtodromadlaTab(pasek[i], pasek[j]);

            }
        }
     }
       return najmniejszy;
 }

double najblizejWykonaj(Punkt *tab,  int rozmiar)
{

    if( rozmiar <= 15)    {
        return dlaPojedynczych(tab, rozmiar);
    }

    int mid = rozmiar/2;
    Punkt midPoint = tab[mid];

    double dl = najblizejWykonaj(tab, mid);
    double dr = najblizejWykonaj(tab + mid, rozmiar-mid);

    double odleglosc = minFunkcja(dl, dr);

    Punkt pasek[rozmiar];
    int j;
    j = 0;

    for(int i= 0; i<rozmiar; i++)
    {
        if(abs(tab[i].stopnie_szerokosc = midPoint.stopnie_szerokosc)<odleglosc)
        {
            pasek[j] = tab[i], j++;
        }
    }

    return minFunkcja(odleglosc, punktyPasek(pasek, j, odleglosc));
}


double wykonajFun(Punkt *tab, int rozmiar)
{
    sort(tab, tab+rozmiar, Sortuj_X());
    return najblizejWykonaj(tab, rozmiar);
}





int main()
{
    int liczba_punktow;
   cin >> liczba_punktow;
    double obwod_sfery1;
    cin >> obwod_sfery1;


    //vector<Punkt> pkt;

    Punkt *tab = new Punkt[liczba_punktow];
    for(int i =0 ; i< liczba_punktow; i++)
    {
         Punkt *p = new Punkt;
         p->stworz();
         tab[i] = *p;
    }

    sort(tab, tab+liczba_punktow, Sortuj_X());

    wykonajFun(tab, liczba_punktow);
    if(punkty.first.nazwa < punkty.second.nazwa)
        cout  << punkty.first.nazwa << " " << punkty.second.nazwa;
    else
        cout  << punkty.second.nazwa << " " << punkty.first.nazwa;






}