// LA3561 Low Cost Air Travel

#include<cstdio>

#include<cstring>

#include<queue>

#include<algorithm>

using namespace std;

const int INF = ;

const int maxn =  + ;

struct Edge {

  int from, to, dist, val;

};

struct HeapNode {

  int d, u;

  bool operator < (const HeapNode& rhs) const {

    return d > rhs.d;

  }

};

struct Dijkstra {

  int n, m;

  vector<Edge> edges;

  vector<int> G[maxn];

  bool done[maxn];    // 是否已永久标号

  int d[maxn];        // s到各个点的距离

  int p[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 dist, int val) {

    edges.push_back((Edge){from, to, dist, val});

    m = edges.size();

    G[from].push_back(m-);

  }

  void dijkstra(int s) {

    priority_queue<HeapNode> Q;

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

    d[s] = ;

    memset(done, , sizeof(done));

    Q.push((HeapNode){, s});

    while(!Q.empty()) {

      HeapNode x = Q.top(); Q.pop();

      int u = x.u;

      if(done[u]) continue;

      done[u] = true;

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

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

        if(d[e.to] > d[u] + e.dist) {

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

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

          Q.push((HeapNode){d[e.to], e.to});

        }

      }

    }

  }

  vector<int> GetShortestPath(int s, int t) {

    vector<int> path;

    while(t != s) {

      path.push_back(edges[p[t]].val);

      t = edges[p[t]].from;

    }

    reverse(path.begin(), path.end());

    return path;

  }

};

//////// 题目相关

#include<map>

int n_cities;

map<int,int> city_id;

int ID(int city) {

  if(city_id.count(city)) return city_id[city];

  city_id[city] = n_cities++;

  return n_cities-;

}

int ID(int visited, int cur) { return (visited-) * n_cities + cur; }

const int maxnt = ;

int cost[maxnt];

vector<int> cities[maxnt], iti;

Dijkstra solver;

int main() {

  int NT, NI, x, len, kase = ;

  while(scanf("%d", &NT) ==  && NT) {

    n_cities = ;

    city_id.clear();

    for(int i = ; i < NT; i++) {

      cities[i].clear();

      scanf("%d%d", &cost[i], &len);

      while(len--) { scanf("%d", &x); cities[i].push_back(ID(x)); }

    }

    scanf("%d", &NI);

    kase++;

    for(int trip = ; trip <= NI; trip++) {

      iti.clear();

      scanf("%d", &len);

      for(int i = ; i < len; i++) { scanf("%d", &x); iti.push_back(ID(x)); }

      solver.init(n_cities * len);

      for(int ticket = ; ticket < NT; ticket++)

        for(int visited = ; visited < len; visited++) {

          int cur = cities[ticket][]; // 当前状态为(visited, cur)

          int next = visited;          // 下一个需要访问的城市在iti中的下标

          for(int leg = ; leg < cities[ticket].size(); leg++) { // 使用前leg段

            if(cities[ticket][leg] == iti[next]) next++; // 行程上多经过一个城市

            solver.AddEdge(ID(visited, cur), ID(next, cities[ticket][leg]), cost[ticket], ticket+);

            if(next == len) break; // 行程单已经走完

          }

        }

      int src = ID(, iti[]), dest = ID(len, iti[len-]);

      solver.dijkstra(src);

      printf("Case %d, Trip %d: Cost = %d\n", kase, trip, solver.d[dest]);

      printf("  Tickets used:");

      vector<int> path = solver.GetShortestPath(src, dest);

      for(int i = ; i < path.size(); i++) printf(" %d", path[i]);

      printf("\n");

    }

  }

  return ;

}