#include <stdio.h>
#include <stdlib.h>

struct  Config { unsigned int machine, network, next, size; };

#define setMachine(m, n, x) ({ struct Config* p = (m); p->network = (n); p->next = (x); })
#define setNetwork(n, m, s) ({ struct Config* p = (n); p->machine = (m); p->size = (s); })

void    exec_command (struct Config* configs, unsigned int m1, unsigned int m2, unsigned int* unique)
{
    struct Config*  machine;
    unsigned int    n1 = configs[m1 - 1].network, n2 = configs[m2 - 1].network;

    if (n1 == 0)
    {
        if (n2 != 0)
        {
            setMachine (&configs[m1 - 1], n2, configs[n2 - 1].machine);
            setNetwork (&configs[n2 - 1], m1, configs[n2 - 1].size + 1);
        }
        else if (m1 != m2)
        {
            setMachine (&configs[m1 - 1], (n1 = ++(*unique)), m2);
            setMachine (&configs[m2 - 1], n1, 0);
            setNetwork (&configs[n1 - 1], m1, 2);
        }
    }
    else if (n2 == 0)
    {
        setMachine (&configs[m2 - 1], n1, configs[n1 - 1].machine);
        setNetwork (&configs[n1 - 1], m2, configs[n1 - 1].size + 1);
    }
    else if (n1 != n2)
    {
        if (configs[n1 - 1].size > configs[n2 - 1].size)
            n1 ^= n2 ^= n1 ^= n2;

        for (machine = &configs[configs[n1 - 1].machine - 1]; machine->next; machine = &configs[machine->next - 1])
            machine->network = n2;

        setMachine (machine, n2, configs[n2 - 1].machine);
        setNetwork (&configs[n2 - 1], configs[n1 - 1].machine, configs[n2 - 1].size + configs[n1 - 1].size);
    }
}

int exec_query (const struct Config* configs, unsigned int m1, unsigned int m2)
{
    return configs[m1 - 1].network == 0 ? m1 == m2 : configs[m1 - 1].network == configs[m2 - 1].network;
}

char    read_char (char* buffer, unsigned int length, unsigned int* offset)
{
    while (*offset < length && buffer[*offset] <= ' ')
        ++(*offset);

    return *offset < length ? buffer[(*offset)++] : '\0';
}

unsigned int    read_uint (char* buffer, unsigned int length, unsigned int* offset)
{
    unsigned int    value = 0;

    for (; *offset < length && ((value == 0 && buffer[*offset] <= ' ') || (buffer[*offset] >= '0' && buffer[*offset] <= '9')); ++(*offset))
        value = (buffer[*offset] <= ' ') ? value : (value * 10 + buffer[*offset] - '0');

    return value;
}

int main (int argc, char* argv[])
{
    struct Config*  configs;
    FILE*           file = fopen (argv[1], "r");
    unsigned int    length, m1, offset = 0, unique = 0, query[2] = {0, 0};
    char*           buffer, type;

    length = !fseek (file, 0, SEEK_END) ? ftell (file) : 0;
    buffer = (char*)malloc (length * sizeof (*buffer));
    fseek (file, 0, SEEK_SET);
    fread (buffer, sizeof (*buffer), length, file);

    for (configs = (struct Config*)calloc (read_uint (buffer, length, &offset), sizeof (*configs)); (type = read_char (buffer, length, &offset)) != '\0'; )
    {
        m1 = read_uint (buffer, length, &offset);

        if (type == 'c')
            exec_command (configs, m1, read_uint (buffer, length, &offset), &unique);
        else
            ++query[!exec_query (configs, m1, read_uint (buffer, length, &offset))];
    }

    printf ("%u,%u\n", query[0], query[1]);

    return 0;
}