#include <stdio.h>
#include <vector>
#include <list>
#include <map>
#include <array>
#include <memory>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <unordered_map>
#include <stdexcept>
#include <numeric>
#include <queue>

using std::string;
using std::vector;


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// util
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

std::vector<std::string> split(const std::string& input, char delimiter)
{
    std::istringstream stream(input);

    std::string field;
    std::vector<std::string> result;
    while (std::getline(stream, field, delimiter)) {
        result.push_back(field);
    }
    return result;
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// user func
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void printList(const vector<int>& list) {
    // print
    for(int i = 0; i < list.size(); i++){
        printf("%d", list[i]);
        if ( i + 1 != list.size() ) {
            printf(" ");
        }
    }
    printf("\n");
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// logic
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


class Node{
public:
    Node(vector<int> adjacency)
        : adjacency(adjacency) 
    {
        // constructer
    }
    // int dist = std::numeric_limits<int>::max();
    int dist = -1;
    bool done = false;
    vector<int> adjacency;
};

class List{
public:
    List(){
        // 0 番目はダミー
        list.push_back(Node({}));
    }
    void Add(Node&& node){
        this->list.push_back(node);
    }
    void Traverse(){
        this->list[1].dist = 0;
        this->list[1].done = true;
        for (auto each : this->list[1].adjacency) {
            this->list[each].dist = 1;
            this->queue.push(each);
        }
        while (!this->queue.empty()) {
            int front = this->queue.front();
            this->queue.pop();
            if(this->list[front].done) continue;

            for (auto each : this->list[front].adjacency) {
                if(this->list[each].dist == -1){
                    this->list[each].dist = this->list[front].dist + 1;
                }else{
                    this->list[each].dist = std::min(this->list[front].dist + 1, this->list[each].dist);
                }
                this->queue.push(each);
            }
            this->list[front].done = true;
        }
    }
    void Print() {
        for (int i = 1; i < list.size(); i++) {
            printf("%d %d\n", i, list[i].dist);
        }
    }
private:
    vector<Node> list;
    std::queue<int> queue;
    // void _traverse(int index, int dist)
    // {
    //     if (dist < this->list[index].dist) {
    //         this->list[index].dist = dist;
    //     }
    //     for(int i = 0; i < current.adjacency.size(); i++) {
    //         _traverse(current.adjacency[i], dist);
    //     }
        
    //     this->list[index].finished = count++;
    // }
};

void solve() {
    List list;
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++){
        int value;
        scanf("%d", &value);
        int k;
        scanf("%d", &k);
        vector<int> adjacency(k);
        for(int j = 0; j < k; j++){
            int link;
            scanf("%d", &link);
            adjacency[j] = link;
        }
        list.Add(Node(adjacency));
    }
    list.Traverse();
    list.Print();
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// main
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
    solve();
    return 0;
}


Measured memory_bytes: 3268