#include <cstdio>

 #include <cstring>

 #include <queue>

 #include <vector>

 using namespace std;

 /// 结点下标从0开始，注意maxn

 struct MCMF {

     static const int maxn =  *  + ;

     static const int INF = 0x3f3f3f3f;

     struct Edge {

         int from, to, cap, flow, cost;

     };

     int n, m;

     vector<Edge> edges;

     vector<int> G[maxn];

     int inq[maxn]; // 是否在队列中

     int d[maxn]; // Bellman-Ford

     int p[maxn]; // 上一条弧

     int a[maxn]; // 可改进量

     void init(int n) {

         this->n = n;

         for(int i = ; i < n; i++) G[i].clear();

         edges.clear();

     }

     void AddEdge(int from, int to, int cap, int cost) {

         edges.push_back((Edge){from, to, cap, , cost});

         edges.push_back((Edge){to, from, , , -cost});

         m = edges.size();

         G[from].push_back(m-);

         G[to].push_back(m-);

     }

     bool BellmanFord(int s, int t, int& flow, int& cost) {

         for(int i = ; i < n; i++) d[i] = INF;

         memset(inq, , sizeof(inq));

         d[s] = ;  inq[s] = ;  p[s] = ;  a[s] = INF;

         queue<int> Q;

         Q.push(s);

         while(!Q.empty()) {

             int u = Q.front();  Q.pop();

             inq[u] = ;

             for(int i = ; i < G[u].size(); i++) {

                 Edge& e = edges[G[u][i]];

                 if(e.cap > e.flow && d[e.to] > d[u] + e.cost) {

                     d[e.to] = d[u] + e.cost;

                     p[e.to] = G[u][i];

                     a[e.to] = min(a[u], e.cap - e.flow);

                     if(!inq[e.to]) {

                         Q.push(e.to);

                         inq[e.to] = ;

                     }

                 }

             }

         }

         if(d[t] == INF) return false;

         //if(flow + a[t] > flow_limit) a[t] = flow_limit - flow;

         flow += a[t];

         cost += d[t] * a[t];

         for(int u = t; u != s; u = edges[p[u]].from) {

             edges[p[u]].flow += a[t];

             edges[p[u]^].flow -= a[t];

         }

         return true;

     }

     // 需要保证初始网络中没有负权圈

     pair<int,int> MincostMaxflow(int s, int t) {

         int flow = , cost = ;

         while(BellmanFord(s, t, flow, cost));

         //while(flow < flow_limit && BellmanFord(s, t, flow_limit, flow, cost));

         return make_pair(flow, cost);

     }

 } mm;

 int main() {

     int n;

     while(scanf("%d", &n) && n) {

         mm.init(n*+);

         int start = , finish = n*+;

         for(int j, d, i = ; i <= n; i++) {

             mm.AddEdge(start, i, , );

             mm.AddEdge(i+n, finish, , );

             while(true) {

                 scanf("%d", &j);

                 if(j == ) break;

                 scanf("%d", &d);

                 mm.AddEdge(i, j+n, , d);

             }

         }

         pair<int,int> p = mm.MincostMaxflow(start, finish);

         if(p.first < n) printf("N\n");

         else printf("%d\n", p.second);

     }

     return ;

 }