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

#define MINUS_INFINITY -10000
#define STRING_LENGTH 50
#define OCTET 8

// Getting the maximum of two numbers
int max(int num1, int num2)
{
    return (num1 > num2) ? num1 : num2;
}

/// Getting a number that exists after a certain character
int get_number(char *text, char delimiter)
{
    int text_length = strlen(text);
    int number_value = 0;
    int number_start_index = -1;
    for(int i = 0; i < text_length; ++i)
    {
        if(text[i] == delimiter)
        {
            number_start_index = i + 1;
            break;
        }
    }

    for(int i = number_start_index; i < text_length - 1 && text[i] >= '0' && text[i] <= '9'; ++i)
    {
        number_value = number_value * 10 + (text[i] - '0');
    }
    return number_value;
}

/// Trying to see if the first n-bits of ip_address are similar to those of network_address
int matches_network(char *ip_address, char *network_address, int prefix_length)
{
    int ip_index = 0, network_index = 0;
    while(true)
    {
        int ip_octet = 0;
        while(ip_address[ip_index] >= '0' && ip_address[ip_index] <= '9')
        {
            ip_octet = ip_octet * 10 + ip_address[ip_index] - '0';
            ip_index++;
        }

        int network_octet = 0;
        while(network_address[network_index] >= '0' && network_address[network_index] <= '9')
        {
            network_octet = network_octet * 10 + network_address[network_index] - '0';
            network_index++;
        }

        int bit_counter = OCTET;
        while(bit_counter)
        {
            if(network_octet % 2 != ip_octet % 2)
            {
                return 0;
            }
            prefix_length--;
            if(prefix_length == 0)
                return 1;
            ip_octet >>= 1;
            network_octet >>= 1;
            bit_counter--;
        }

        if(network_address[network_index] == '/') break;
        ip_index++;
        network_index++;
    }
    return 1;
}

// Locating the default IP 0.0.0.0 /0 if it exists
int find_default_route(char **routing_entries, int num_routing_entries)
{
    for(int i = 0; i < num_routing_entries; ++i)
    {
        int is_default = true;
        for(int j = 0; j < strlen(routing_entries[i]); ++j)
        {
            if(routing_entries[i][j] == '/')
            {
                break;
            }
            if(routing_entries[i][j] != '0' && routing_entries[i][j] != '.')
            {
                is_default = false;
                break;
            }
        }
        if(is_default) return get_number(routing_entries[i], ' ');
    }
    return -1;
}


int main()
{
    // Reading the first addresses
    int num_routing_entries;
    scanf("%d", &num_routing_entries);
    getchar();
    char **routing_entries = malloc(sizeof(char *) * (num_routing_entries + 1));
    for(int i = 0; i < num_routing_entries; ++i)
    {
        routing_entries[i] = malloc(sizeof(char) * (STRING_LENGTH));
    }

    for(int i = 0; i < num_routing_entries; ++i)
    {
        fgets(routing_entries[i], STRING_LENGTH, stdin);
    }

    int default_route = find_default_route(routing_entries, num_routing_entries);

    // Reading the second addresses
    int num_ips;
    scanf("%d", &num_ips);
    getchar();
    char **ip_addresses = malloc(sizeof(char *) * (num_ips + 1));
    for(int i = 0; i < num_ips; ++i)
    {
        ip_addresses[i] = malloc(sizeof(char) * (STRING_LENGTH));
    }
    for(int i = 0; i < num_ips; ++i)
    {
        fgets(ip_addresses[i], STRING_LENGTH, stdin);
    }


    // Solving the problem
    for(int i = 0; i < num_ips; ++i)
    {
        int max_prefix_length = MINUS_INFINITY, best_route_id = -1;
        for(int j = 0; j < num_routing_entries; ++j)
        {
            int entry_prefix = get_number(routing_entries[j], '/');

            if(matches_network(ip_addresses[i], routing_entries[j], entry_prefix))
            {
                if(entry_prefix > max_prefix_length)
                {
                    max_prefix_length = entry_prefix;
                    best_route_id = get_number(routing_entries[j], ' ');
                }
            }
        }
        if(best_route_id == -1 && default_route != -1)
        {
            best_route_id = default_route;
        }
        printf("%d\n", best_route_id);
    }

    // Freeing memory
    for(int i = 0; i < num_routing_entries; ++i)
    {
        free(routing_entries[i]);
    }
    free(routing_entries);

    for(int i = 0; i < num_ips; ++i)
    {
        free(ip_addresses[i]);
    }
    free(ip_addresses);

    return 0;
}