#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <iterator>
#include <functional>
#include <string>
#include <queue>
#include <numeric>
#include <fstream>

using namespace std;

struct edge_t {
    edge_t *next;
    struct vertex_t *dest;
    int weight;
};

struct vertex_t {
    edge_t *edges;
    int dist;
    bool operator < (vertex_t const vertex) const {
        return dist > vertex.dist;
    }
};

edge_t edges[100000];
edge_t *end_of_edges(edges);
vertex_t vertices[1000];

int nr_vertices(100);

inline
void
add_edge(int src, int dest, int weight)
{
    end_of_edges->next = vertices[src].edges;
    end_of_edges->dest = &vertices[dest];
    end_of_edges->weight = weight;
    vertices[src].edges = end_of_edges++;

    return;
}

void
dijkstra(vertex_t *source)
{
    priority_queue<vertex_t> pq;

    for (vertex_t *iter = vertices; iter != vertices + nr_vertices; ++iter) {
        iter->dist = 1000000;
    }
    source->dist = 0;

    pq.push(*source);
    while (!pq.empty()) {
        vertex_t current(pq.top());

        pq.pop();
        for (edge_t *iter = current.edges; iter; iter = iter->next) {
            if (iter->dest->dist > current.dist + iter->weight) {
                iter->dest->dist = current.dist + iter->weight;
                pq.push(*iter->dest);
            }
        }
    }

    return;
}

int
main()
{
    ifstream fin("comehome.in");
    ofstream fout("comehome.out");
    vector<int> dests;
    int nr_edges;
    int source;
    int result(0x7fffffff);
    int no;

    cin.rdbuf(fin.rdbuf());
    cout.rdbuf(fout.rdbuf());

    cin >> nr_edges;
    while (nr_edges--) {
        char src, dest;
        int weight;

        cin >> src >> dest >> weight;
        src -= 'A';
        dest -= 'A';
        if (src < ('Z' - 'A')) {
            dests.push_back(src);
        }
        if (dest < ('Z' - 'A')) {
            dests.push_back(dest);
        }

        add_edge(src, dest, weight);
        add_edge(dest, src, weight);
    }

    dijkstra(&vertices['Z' - 'A']);
    for (vector<int>::iterator iter = dests.begin(); iter != dests.end(); ++iter) {
        if (vertices[*iter].dist < result) {
            result = vertices[*iter].dist;
            no = *iter;
        }
    }

    cout << (char)(no + 'A') << " " << result << endl;

    return 0;
}