Problem: You are given a weighted directed graph, consisting of n vertices and m edges. You should answer q queries of two types:

  * 1 v — find the length of shortest path from vertex 1 to vertex v. 
  * 2 c l1 l2 ... lc — add 1 to weights of edges with indices l1, l2, ..., lc. 

Input

The first line of input data contains integers n, m, q (1 ≤ n, m ≤ 105, 1 ≤ q ≤ 2000) — the number of vertices and edges in the graph, and the number of requests correspondingly.

Next m lines of input data contain the descriptions of edges: i-th of them contains description of edge with index i — three integers ai, bi, ci (1 ≤ ai, bi ≤ n, 0 ≤ ci ≤ 109) — the beginning and the end of edge, and its initial weight correspondingly.

Next q lines of input data contain the description of edges in the format described above (1 ≤ v ≤ n, 1 ≤ lj ≤ m). It's guaranteed that inside single query all lj are distinct. Also, it's guaranteed that a total number of edges in all requests of the second type does not exceed 106.

Output

For each query of first type print the length of the shortest path from 1 to v in a separate line. Print -1, if such path does not exists.

Examples

Input

3 2 9
1 2 0
2 3 0
2 1 2
1 3
1 2
2 1 1
1 3
1 2
2 2 1 2
1 3
1 2


Output

1
0
2
1
4
2


Input

5 4 9
2 3 1
2 4 1
3 4 1
1 2 0
1 5
1 4
2 1 2
2 1 2
1 4
2 2 1 3
1 4
2 1 4
1 4


Output

-1
1
2
3
4

Note

The description of changes of the graph in the first sample case:

<image>

The description of changes of the graph in the second sample case:

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int q;
vector<pair<int, int> > v[100002];
pair<int, int> ed[100002];
int id1[100002];
int id2[100002];
long long int dist[100002];
priority_queue<pair<long long int, int>, vector<pair<long long int, int> >,
               greater<pair<long long int, int> > >
    qq;
int inc[100002];
pair<int, int> ar[2 * 100002];
int star[100002];
int en[100002];
int C[100002];
int top[1000002];
int pr[1000002];
int val[5000002];
int sz;
int read_int() {
  int num = 0;
  while (1) {
    char c = getchar();
    if (!isdigit(c)) {
      continue;
    }
    num += c - '0';
    break;
  }
  while (1) {
    char c = getchar();
    if (!isdigit(c)) {
      return num;
    }
    num *= 10;
    num += c - '0';
  }
}
int main() {
  cin >> n >> m >> q;
  for (int i = 0; i < m; i++) {
    int a, b, c;
    a = read_int();
    b = read_int();
    c = read_int();
    a--;
    b--;
    id1[i] = v[a].size();
    id2[i] = v[b].size();
    v[a].push_back(make_pair(b, c));
    ed[i] = make_pair(a, b);
    C[i] = c;
  }
  for (int i = 0; i < 100002; i++) {
    dist[i] = LLONG_MAX;
  }
  dist[0] = 0;
  qq.push({0, 0});
  while (!qq.empty()) {
    int b = qq.top().second;
    if (dist[b] != qq.top().first) {
      qq.pop();
      continue;
    }
    qq.pop();
    for (auto c : v[b]) {
      int &go = c.first;
      long long int cost = dist[b] + c.second;
      if (dist[go] > cost) {
        dist[go] = cost;
        qq.push({cost, go});
      }
    }
  }
  int las_ty = 1;
  int mxx = 0;
  int zz = 0;
  for (int i = 0; i < n; i++) {
    star[i] = zz;
    for (int j = 0; j < v[i].size(); j++) {
      ar[zz] = v[i][j];
      ar[zz].second = 0;
      zz++;
    }
    en[i] = zz;
  }
  for (int i = 0; i < m; i++) {
    if (dist[ed[i].first] == LLONG_MAX) continue;
    ar[star[ed[i].first] + id1[i]].second =
        C[i] + dist[ed[i].first] - dist[ed[i].second];
  }
  memset(top, -1, sizeof(top));
  while (q--) {
    int ty = read_int();
    if (ty == 1 && las_ty == 2) {
      for (int i = 0; i < n; i++) inc[i] = INT_MAX;
      inc[0] = 0;
      sz = 0;
      pr[sz] = top[0];
      top[0] = sz;
      val[sz] = 0;
      sz++;
      for (int j = 0; j <= mxx; j++) {
        for (; top[j] != -1;) {
          int cur = val[top[j]];
          top[j] = pr[top[j]];
          if (inc[cur] != j) continue;
          int cost = inc[cur];
          for (int idx = star[cur]; idx < en[cur]; idx++) {
            int go = ar[idx].first;
            int nex = inc[cur] + ar[idx].second;
            if (inc[go] > nex && nex <= mxx) {
              inc[go] = nex;
              pr[sz] = top[nex];
              top[nex] = sz;
              val[sz] = go;
              sz++;
            }
            ar[idx].second = 0;
          }
        }
      }
      for (int i = 0; i < n; i++)
        if (inc[i] != INT_MAX) dist[i] += inc[i];
      for (int i = 0; i < m; i++) {
        if (dist[ed[i].first] == LLONG_MAX) continue;
        ar[star[ed[i].first] + id1[i]].second =
            C[i] + dist[ed[i].first] - dist[ed[i].second];
      }
      mxx = 0;
    }
    las_ty = ty;
    if (ty == 2) {
      int cnt = read_int();
      for (int j = 0; j < cnt; j++) {
        int id = read_int();
        id--;
        ar[star[ed[id].first] + id1[id]].second++;
        C[id]++;
      }
      mxx += cnt;
      continue;
    }
    int node;
    node = read_int();
    node--;
    if (dist[node] == LLONG_MAX) {
      puts("-1");
      continue;
    }
    printf("%lld\n", dist[node]);
  }
  return 0;
}