#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct Node {
  int index;

  // paths info
  vector<int> to;
  vector<int> cost;

  // Dijkstra-related
  bool done;
  int c; // cost
  int from;

  bool operator>(const Node &a) const {
    if (c != a.c) { return (c > a.c); }
    return (index > a.index);
  }
};

int main() {
  int n;
  int casenum = 0;
  while (cin >> n, n) {
    casenum++;

    Node nodes[11];
    for (int i=1; i<=n; i++) {
      nodes[i].index = i;

      int m;
      cin >> m;
      for (int j=0; j<m; j++) {
        int to, cost;
        cin >> to >> cost;
        nodes[i].to.push_back(to);
        nodes[i].cost.push_back(cost);
      }
      nodes[i].done = false;
      nodes[i].c = -1;
    }

    int start, end;
    cin >> start >> end;

    // Dijkstra's shortest path find
    nodes[start].c = 0;
    priority_queue<Node, vector<Node>, greater<Node> > q;
    q.push(nodes[start]);
    while ( !q.empty() ) {
      Node node = q.top();
      q.pop();
      if (node.done) { continue; }

      node.done = true;
      for (int i=0; i<node.to.size(); i++) {
        int to = node.to[i];
        int cost = node.c + node.cost[i];
        if (nodes[to].c < 0 || cost < nodes[to].c) {
          nodes[to].c = cost;
          nodes[to].from = node.index;
          q.push(nodes[to]);
        }
      }
    }

    // constructing the answer path
    vector<int> path;
    for (int idx = end; idx != start; idx = nodes[idx].from) {
      path.push_back(idx);
    }
    path.push_back(start);

    cout << "Case " << casenum << ": Path =";
    for (int i=path.size()-1; i>=0; i--) {
      cout << " " << path[i];
    }
    cout << "; " << nodes[end].c << " second delay" << endl;
  }

  return 0;
}