#include <bits/stdc++.h>

using namespace std;

#define int long long
#define fir first
#define sec second
#define mkp make_pair 
#define pb push_back
#define lep( i, l, r ) for ( int i = ( l ); i <= ( r ); ++ i )
#define rep( i, r, l ) for ( int i = ( r ); i >= ( l ); -- i )

typedef long long ll;
typedef long double ld;
typedef pair < int, int > pii;

char _c; bool _f; template < class type > inline void read ( type &x ) {
	_f = 0, x = 0;
	while ( _c = getchar (), !isdigit ( _c ) ) if ( _c == '-' ) _f = 1;
	while ( isdigit ( _c ) ) x = x * 10 + _c - '0', _c = getchar (); if ( _f ) { x = -x; }
}

template < class type > inline void chkmin ( type &x, type y ) { x = ( x <= y ? x : y ); }
template < class type > inline void chkmax ( type &x, type y ) { x = ( x >= y ? x : y ); }

const int N = 205;
const int M = 4e5 + 5;

int n, m, c, k, a, t;
int dis[N][N], p[M][5], res[5];

int tmp[5], link[5][5];

struct Node {
  int val[5][5];
  Node () {
    for ( int i = 1; i <= k; i ++ ) {
      for ( int j = 1; j <= k; j ++ ) {
        val[i][j] = 1e18;
      }
    }
  }
} tree[M << 2];

Node merge ( Node ls, Node rs, int lt, int rt, int mid ) {
  memset ( link, 0x3f, sizeof ( link ) );
  vector < int > f, g;
  for ( int i = 1; i <= k; i ++ ) {
    for ( int j = 1; j <= k; j ++ ) {
      if ( dis[p[mid][i]][p[mid + 1][j]] < 1e9 ) {
        f.clear (), g.clear ();
        f.push_back ( 0 ), g.push_back ( 0 );
        for ( int l = 1; l <= k; l ++ ) {
          if ( l != i ) {
            f.push_back ( l );
          }
        }
        for ( int l = 1; l <= k; l ++ ) {
          if ( l != j ) {
            g.push_back ( l );
          }
        }
        if ( k - 1 == 0 ) {
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] );
        }
        else if ( k - 1 == 1 ) {
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[1]]] );
        }
        else if ( k - 1 == 2 ) {
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[1]]] + dis[p[mid][f[2]]][p[mid + 1][g[2]]] );
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[2]]] + dis[p[mid][f[2]]][p[mid + 1][g[1]]] );
        }
        else if ( k - 1 == 3 ) {
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[1]]] + dis[p[mid][f[2]]][p[mid + 1][g[2]]] + dis[p[mid][f[3]]][p[mid + 1][g[3]]] );
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[1]]] + dis[p[mid][f[2]]][p[mid + 1][g[3]]] + dis[p[mid][f[3]]][p[mid + 1][g[2]]] );
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[2]]] + dis[p[mid][f[2]]][p[mid + 1][g[1]]] + dis[p[mid][f[3]]][p[mid + 1][g[3]]] );
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[2]]] + dis[p[mid][f[2]]][p[mid + 1][g[3]]] + dis[p[mid][f[3]]][p[mid + 1][g[1]]] );
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[3]]] + dis[p[mid][f[2]]][p[mid + 1][g[2]]] + dis[p[mid][f[3]]][p[mid + 1][g[1]]] );
          link[i][j] = min ( link[i][j], a * dis[p[mid][i]][p[mid + 1][j]] + dis[p[mid][f[1]]][p[mid + 1][g[3]]] + dis[p[mid][f[2]]][p[mid + 1][g[1]]] + dis[p[mid][f[3]]][p[mid + 1][g[2]]] );
        }
      }
    }
  }
  // cout << "cy\n";
  // cout << mid << '\n';
  // for ( int i = 1; i <= k; i ++ ) {
  //   for ( int j = 1; j <= k; j ++ ) {
  //     cout << link[i][j] << " ";
  //   }
  //   cout << '\n';
  // }
  Node ans;
  if ( rt - lt + 1 <= 2 ) {
    for ( int i = 1; i <= k; i ++ ) {
      for ( int j = 1; j <= k; j ++ ) {
        ans.val[i][j] = link[i][j];
      }
    }
  }
  else if ( mid - lt + 1 == 1 ) {
    for ( int i = 1; i <= k; i ++ ) {
      for ( int j = 1; j <= k; j ++ ) {
        for ( int l = 1; l <= k; l ++ ) {
          ans.val[i][j] = min ( ans.val[i][j], rs.val[j][l] + link[i][j] );
        }
      }
    }
  }
  else if ( rt - mid == 1 ) {
    for ( int i = 1; i <= k; i ++ ) {
      for ( int j = 1; j <= k; j ++ ) {
        for ( int l = 1; l <= k; l ++ ) {
          ans.val[i][l] = min ( ans.val[i][l], ls.val[i][j] + link[j][l] );
        }
      }
    }
  }
  else {
    for ( int i = 1; i <= k; i ++ ) {
      for ( int j = 1; j <= k; j ++ ) {
        for ( int l = 1; l <= k; l ++ ) {
          for ( int o = 1; o <= k; o ++ ) {
            ans.val[i][o] = min ( ans.val[i][0], ls.val[i][j] + rs.val[l][o] + link[j][l] );
          }
        }
      }
    }
  }
  // cout << mid << '\n';
  // for ( int i = 1; i <= k; i ++ ) {
  //   for ( int j = 1; j <= k; j ++ ) {
  //     cout << ans.val[i][j] << " ";
  //   }
  //   cout << '\n';
  // }
  return ans;
}

void build ( int node, int lt, int rt ) {
  if ( lt == rt ) {
    return ;
  }
  int mid = lt + rt >> 1;
  build ( node << 1, lt, mid ), build ( node << 1 | 1, mid + 1, rt );
  tree[node] = merge ( tree[node << 1], tree[node << 1 | 1], lt, rt, lt + rt >> 1 );
}

void update ( int node, int lt, int rt, int x ) {
  if ( x < lt || x > rt ) {
    return ;
  }
  if ( lt == rt && lt == x ) {
    for ( int i = 1; i <= k; i ++ ) {
      p[lt][i] = tmp[i];
    }
    return ;
  }
  int mid = lt + rt >> 1;
  update ( node << 1, lt, mid, x ), update ( node << 1 | 1, mid + 1, rt, x );
  tree[node] = merge ( tree[node << 1], tree[node << 1 | 1], lt, rt, lt + rt >> 1 );
}

Node query ( int node, int lt, int rt, int x, int y ) {
  if ( x <= lt && rt <= y ) {
    return tree[node];
  }
  int mid = lt + rt >> 1;
  if ( x <= mid && mid + 1 <= y ) {
    return merge ( query ( node << 1, lt, mid, x, y ), query ( node << 1 | 1, mid + 1, rt, x, y ), lt, rt, mid );
  }
  else if ( x <= mid ) {
    return query ( node << 1, lt, mid, x, y );
  }
  else if ( mid + 1 <= y ) {
    return query ( node << 1 | 1, mid + 1, rt, x, y );
  }
}

void Solve () {
  ios :: sync_with_stdio ( false );
  cin.tie ( 0 ), cout.tie ( 0 );
  cin >> n >> m >> c >> k >> a >> t;
  for ( int i = 1; i <= n; i ++ ) {
    for ( int j = 1; j <= n; j ++ ) {
      if ( i != j ) {
        dis[i][j] = 1e18;
      }
    }
  }
  for ( int i = 1; i <= m; i ++ ) {
    int u, v, w;
    cin >> u >> v >> w;
    dis[u][v] = dis[v][u] = min ( dis[u][v], w );
  }
  for ( int k = 1; k <= n; k ++ ) {
    for ( int i = 1; i <= n; i ++ ) {
      for ( int j = 1; j <= n; j ++ ) {
        dis[i][j] = min ( dis[i][j], dis[i][k] + dis[k][j] );
      }
    }
  }
  // for ( int i = 1; i <= n; i ++ ) {
  //   for ( int j = 1; j <= n; j ++ ) {
  //     cout << dis[i][j] << " ";
  //   }
  //   cout << '\n';
  // }
  for ( int i = 1; i <= c; i ++ ) {
    for ( int j = 1; j <= k; j ++ ) {
      cin >> p[i][j];
    }
  }
  build ( 1, 1, c );
  // for ( int i = 1; i < c; i ++ ) {
  //   cout << query ( 1, 1, c, i, i + 1 ).val[1][1] << " ";
  // }
  while ( t -- ) {
    int op;
    cin >> op;
    if ( op == 1 ) {
      int x;
      cin >> x;
      for ( int i = 1; i <= k; i ++ ) {
        cin >> tmp[i];
      }
      update ( 1, 1, c, x );
    }
    else {
      int l, r;
      cin >> l >> r;
      Node res = query ( 1, 1, c, l, r );
      int ans = 1e18;
      for ( int i = 1; i <= k; i ++ ) {
        for ( int j = 1; j <= k; j ++ ) {
          ans = min ( ans, res.val[i][j] );
        }
      }
      cout << ans << '\n';
    }
  }
}

signed main () {
#ifdef judge
  freopen ( "Code.in", "r", stdin );
  freopen ( "Code.out", "w", stdout );
  freopen ( "Code.err", "w", stderr );
#endif
  Solve ();
	return 0;
}