#include <bits/stdc++.h>   using namespace std;   static struct FastInput {     static constexpr int BUF_SIZE = 1 << 20;     char buf[BUF_SIZE];     size_t chars_read = 0;     size_t buf_pos = 0;     FILE* in = stdin;     char cur = 0;     inline char get_char() {       if (buf_pos >= chars_read) {         chars_read = fread(buf, 1, BUF_SIZE, in);         buf_pos = 0;         buf[0] = (chars_read == 0 ? -1 : buf[0]);       }       return cur = buf[buf_pos++];     }     inline void tie(int) {}     inline explicit operator bool() { return cur != -1; }     inline static bool is_blank(char c) { return c <=    ; }     inline bool skip_blanks() {       while (is_blank(cur) && cur != -1) {         get_char();       }       return cur != -1;     }     inline FastInput& operator>>(char& c) {       skip_blanks();       c = cur;       return *this;     }     inline FastInput& operator>>(string& s) {       if (skip_blanks()) {         s.clear();         do {           s += cur;         } while (!is_blank(get_char()));       }       return *this;     }     template <typename T>     inline FastInput& read_integer(T& n) {       n = 0;       if (skip_blanks()) {         int sign = +1;         if (cur ==  - ) {           sign = -1;           get_char();         }         do {           n += n + (n << 3) + cur -  0 ;         } while (!is_blank(get_char()));         n *= sign;       }       return *this;     }     template <typename T>     inline typename enable_if<is_integral<T>::value, FastInput&>::type operator>>(         T& n) {       return read_integer(n);     }     inline FastInput& operator>>(__int128& n) { return read_integer(n); }     template <typename T>     inline typename enable_if<is_floating_point<T>::value, FastInput&>::type     operator>>(T& n) {       n = 0;       if (skip_blanks()) {         string s;         (*this) >> s;         sscanf(s.c_str(),  %lf , &n);       }       return *this;     }   } fast_input;   static struct FastOutput {     static constexpr int BUF_SIZE = 1 << 20;     char buf[BUF_SIZE];     size_t buf_pos = 0;     static constexpr int TMP_SIZE = 1 << 20;     char tmp[TMP_SIZE];     FILE* out = stdout;     inline void put_char(char c) {       buf[buf_pos++] = c;       if (buf_pos == BUF_SIZE) {         fwrite(buf, 1, buf_pos, out);         buf_pos = 0;       }     }     ~FastOutput() { fwrite(buf, 1, buf_pos, out); }     inline FastOutput& operator<<(char c) {       put_char(c);       return *this;     }     inline FastOutput& operator<<(const char* s) {       while (*s) {         put_char(*s++);       }       return *this;     }     inline FastOutput& operator<<(const string& s) {       for (int i = 0; i < (int)s.size(); i++) {         put_char(s[i]);       }       return *this;     }     template <typename T>     inline char* integer_to_string(T n) {       char* p = tmp + TMP_SIZE - 1;       if (n == 0) {         *--p =  0 ;       } else {         bool is_negative = false;         if (n < 0) {           is_negative = true;           n = -n;         }         while (n > 0) {           *--p = (char)( 0  + n % 10);           n /= 10;         }         if (is_negative) {           *--p =  - ;         }       }       return p;     }     template <typename T>     inline typename enable_if<is_integral<T>::value, char*>::type stringify(T n) {       return integer_to_string(n);     }     inline char* stringify(__int128 n) { return integer_to_string(n); }     template <typename T>     inline typename enable_if<is_floating_point<T>::value, char*>::type stringify(         T n) {       sprintf(tmp,  %.17f , n);       return tmp;     }     template <typename T>     inline FastOutput& operator<<(const T& n) {       auto p = stringify(n);       for (; *p != 0; p++) {         put_char(*p);       }       return *this;     }   } fast_output;   const int N = 1e6 + 3;   vector<int> inq[N];   int main() {     ios::sync_with_stdio(false);     fast_input.tie(0);     int n, m, q;     fast_input >> n >> m >> q;     vector<vector<int>> edge(n + 1);     vector<tuple<int, int, int>> edges;     for (int i = 0; i < m; i++) {       int u, v, w;       fast_input >> u >> v >> w;       edges.emplace_back(u, v, w);       edge[u].emplace_back(i);     }     priority_queue<pair<long long, int>> pq;     const long long inf = 1e18;     vector<long long> d(n + 1, inf);     d[1] = 0;     pq.emplace(d[1], 1);     while ((int)pq.size()) {       auto x = pq.top();       pq.pop();       if (-x.first != d[x.second]) continue;       int v = x.second;       for (auto& x : edge[v]) {         int u = get<1>(edges[x]);         if (d[u] > d[v] + get<2>(edges[x])) {           d[u] = d[v] + get<2>(edges[x]);           pq.emplace(-d[u], u);         }       }     }     vector<int> add(m);     for (int i = 0; i < m; i++) {       auto& x = edges[i];       add[i] = get<2>(x) - (d[get<1>(x)] - d[get<0>(x)]);     }     int up = 0;     while (q--) {       int type;       fast_input >> type;       if (type == 1) {         int v;         fast_input >> v;         if (up) {           vector<int> dist(n + 1, (int)1e9);           dist[1] = 0;           inq[0].emplace_back(1);           for (int i = 0; i <= up; i++) {             for (int j = 0; j < (int)inq[i].size(); j++) {               int v = inq[i][j];               if (dist[v] != i) continue;               for (auto& x : edge[v]) {                 int u = get<1>(edges[x]);                 if (dist[u] > dist[v] + add[x]) {                   dist[u] = dist[v] + add[x];                   if (dist[u] <= up) inq[dist[u]].emplace_back(u);                 }               }             }             inq[i].clear();           }           for (int i = 1; i <= n; i++) d[i] = min(d[i] + dist[i], inf);           for (int i = 0; i < m; i++) {             auto& x = edges[i];             add[i] -= (dist[get<1>(x)] - dist[get<0>(x)]);           }           up = 0;         }         if (d[v] != inf)           fast_output << d[v] <<   n ;         else           fast_output <<  -1 n ;       } else {         int foo;         fast_input >> foo;         for (int i = 0; i < foo; i++) {           int x;           fast_input >> x;           --x;           add[x]++;         }         up += foo;       }     }   }   