#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define inf 0x7fFFffFF

short nodes, paths, chs;
short** plst, * viz, * ord, * pord;
unsigned int*** list, * dist, * globd;
char** name;

inline int cmp(const void* a, const void* b)
{
    return strcmp(name[*((const short*)a)], name[*((const short*)b)]);
}

inline int comp(const void* a, const void* b)
{
    return plst[*((const short*)a)][chs] - plst[*((const short*)b)][chs];
}

short getindex(const char* string)
{
    short lo = 1, hi = nodes, mid, res;
    while (lo <= hi) {
        mid = (lo + hi) / 2;
        res = strcmp(string, name[ord[mid]]);
        if (!res) {
            return ord[mid];
        } else if (res > 0) {
            lo = mid + 1;
        } else {
            hi = mid - 1;
        }
    }
    return 0;
}

void read()
{
    short i, j, nbs, nb;
    unsigned int cst;
    char tmp[11];
    scanf("%hd", &nodes);
    name = (char**) malloc((nodes + 1) * sizeof(char*));
    ord = (short*) malloc((nodes + 1) * sizeof(short));
    list = (unsigned int***) malloc((nodes + 1) * sizeof(unsigned int**));
    for (i = 1; i <= nodes; ++i) {
        scanf("%s\n%hd", tmp, &nbs);
        name[i] = (char*) malloc((strlen(tmp) + 1) * sizeof(char));
        ord[i] = i;
        strcpy(name[i], tmp);
        list[i] = (unsigned int**) malloc((nbs + 1) * sizeof(unsigned int*));
        list[i][0] = (unsigned int*) malloc(sizeof(unsigned int));
        list[i][0][0] = nbs;
        for (j = 1; j <= nbs; ++j) {
            scanf("%hd %u", &nb, &cst);
            list[i][j] = (unsigned int*) malloc(2 * sizeof(unsigned int));
            list[i][j][0] = nb;
            list[i][j][1] = cst;
        }
    }
    qsort(ord + 1, nodes, sizeof(short), cmp);
    scanf("%hd", &paths);
    plst = (short**) malloc(paths * sizeof(short*));
    pord = (short*) malloc(paths * sizeof(short));
    globd = (unsigned int*) malloc(paths * sizeof(unsigned int));
    for (i = 0; i < paths; ++i) {
        plst[i] = (short*) malloc(2 * sizeof(short));
        pord[i] = i;
        scanf("%s", tmp);
        plst[i][0] = getindex(tmp);
        scanf("%s", tmp);
        plst[i][1] = getindex(tmp);
    }
    viz = (short*) malloc((nodes + 1) * sizeof(short));
    dist = (unsigned int*) malloc((nodes + 1) * sizeof(unsigned int));
}

short getoptim()
{
    short maxs, maxd, i, * vecs, * vecd;
    maxs = maxd = 0;
    vecs = (short*) calloc(nodes + 1, sizeof(short));
    vecd = (short*) calloc(nodes + 1, sizeof(short));
    for (i = 0; i < paths; ++i) {
        ++vecs[plst[i][0]];
        ++vecd[plst[i][1]];
        if (vecs[plst[i][0]] > maxs) {
            maxs = vecs[plst[i][0]];
        }
        if (vecd[plst[i][1]] > maxd) {
            maxd = vecd[plst[i][1]];
        }
    }
    free(vecs);
    free(vecd);
    return maxs > maxd ? 0 : 1;
}

void process()
{
    short i, j, src, dest, var, flag, old = 0, ind, first, second;
    unsigned int min;
    chs = 0; //getoptim(); TLE :/
    if (chs) {
        first = 1;
        second = 0;
    } else {
        first = 0;
        second = 1;
    }
    qsort(pord, paths, sizeof(short), comp);
    for (i = 0; i < paths; ++i) {
        ind = pord[i];
        src = plst[ind][first];
        dest = plst[ind][second];
        if (old == src) {
            globd[ind] = dist[dest];
            continue;
        } else {
            old = src;
        }
        for (j = 0; j <= nodes; ++j) {
            viz[j] = 0;
            dist[j] = inf;
        }
        dist[src] = 0;
        var = src;
        do {
            viz[var] = 1;
            for (j = 1; j <= list[var][0][0]; ++j) {
                if (dist[var] + list[var][j][1] < dist[list[var][j][0]]) {
                    dist[list[var][j][0]] = dist[var] + list[var][j][1];
                }
            }
            flag = 0;
            min = inf;
            for (j = 1; j <= nodes; ++j) {
                if (dist[j] < min && !viz[j]) {
                    min = dist[j];
                    var = j;
                    flag = 1;
                }
            }
        } while (flag);
        globd[ind] = dist[dest];
    }
    for (i = 0; i < paths; ++i) {
        printf("%u\n", globd[i]);
    }
}

void clean()
{
    short i, j;
    nodes = paths = 0;
    free(viz);
    free(dist);
    for (i = 1; i <= nodes; ++i) {
        free(name[i]);
        for (j = 1; j <= list[i][0][0]; ++j) {
            free(list[i][j]);
        }
        free(list[i][0]);
        free(list[i]);
    }
    free(name);
    free(list);
    for (i = 0; i < paths; ++i) {
        free(plst[i]);
    }
    free(plst);
    free(ord);
    free(pord);
    free(globd);
}

int main()
{
    short tests;
    //freopen("shpath.in", "rt", stdin);
    for (scanf("%hd", &tests); tests; --tests) {
        read();
        process();
        clean();
    }
    return 0;
}