#include <iostream>
#include <utility>
#include <vector>
#include <algorithm>
#include "set"

using std::cin;
using std::cout;
using std::vector;
using std::pair;
using std::set;
using std::make_pair;

const int inf = 1000000000;

template <typename T>
class heap {
public:
    vector<T> v;
    T inf;
    heap (T _inf) {
        inf = _inf;
    }

    void heal_heap(int looking) {
        int interesting_child = looking * 2 + 1;
        if (interesting_child >= v.size()) {
            return;
        }
        if (interesting_child + 1 != v.size() && v[looking * 2 + 1] > v[looking * 2 + 2]) {
            ++interesting_child;
        }
        if (v[looking] <= v[interesting_child])
            return;
        std::swap(v[looking], v[interesting_child]);
        heal_heap(interesting_child);
    }


    void push(T n, int len) {
        T c;
        int looking = 0;
        int j = 0, l = len;
        while (len) {
            ++j;
            len /= 2;
        }
        --j;
        while (true) {
            if (v[looking] > n) {
                c = n;
                n = v[looking];
                v[looking] = c;
            }
            looking = l >> j;
            if (j < 0)
                break;
            --j;
        }
    }

    void add(T n) {
        v.push_back(inf);
        push(n, v.size() - 1);
    }

    T minimum() {
        return v[0];
    }

    T delete_minimum() {
        v[0] = v.back();
        v.pop_back();
        heal_heap(0);
    }

    int size() {
        return v.size();
    }
};

inline void Dijkstra(int start, vector<vector<pair<int, int> > > &v, vector<pair<int, int> > &answer){
    int n = v.size() - 1;
    answer.clear();
    heap<pair<int, int> > buffer(make_pair(inf, inf));
    vector<int> len(n+1, inf);
    len[start] = 0;
    buffer.add(make_pair(0, start));
    pair<int, int> it;
    while (buffer.size()) {
        it = buffer.minimum();
        int now = it.second;
        int length = it.first;
        buffer.delete_minimum();
        if (length > len[now])
            continue;
        answer.push_back(make_pair(now, length));
        for (int j = 0; j < v[now].size(); ++j) {
            if (len[v[now][j].second] > length + v[now][j].first) {
                len[v[now][j].second] = length + v[now][j].first;
                buffer.add(make_pair(len[v[now][j].second], v[now][j].second));
            }
        }
    }

}

inline void Input(int &n, vector<vector<pair<int, int> > > &v) {
    scanf("%d", &n);
    int m;
    v.resize(n+1);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &m);
        int a, b;
        v[i].resize(m);
        for (int j = 0; j < m; ++j) {
            scanf("%d %d", &a, &b);
            v[i][j] = (std::make_pair(a, b));
        }
    }
}

inline void MakeAns(int &n, int &d, vector<vector<pair<int, int> > > &v, vector<pair<int, int> > &len, vector<pair<int, int> > &ans) {
    for (int i = 1; i <= n; ++i) {
        Dijkstra(i, v, len);
        int j = len.size() - 1;
        if (d < len[j].second) {
            ans.clear();
            d = len[j].second;
        }
        while (len[j].second == d) {
            ans.push_back(make_pair(i, len[j].first));
            --j;
        }
    }
}

inline void Output(int &d, vector<pair<int, int> > &ans) {
    printf("%d\n", d);
    for (int i = 0; i < ans.size(); ++i) {
        printf("%d %d\n", ans[i].first, ans[i].second);
    }
}

int main() {
    int n;

    vector<vector<pair<int, int> > > v;
    Input(n, v);
    vector<pair<int, int> > len(n+1);
    int d = -1;
    vector<pair<int, int> > ans(n+1);


    MakeAns(n, d, v, len, ans);

    Output(d, ans);

    return 0;
}