#include <iostream>
#include <cstring>

using namespace std;

const int N = 510;
int n, m;   //n代表点的数量，m代表边的数量 
int g[N][N];  //邻接矩阵-->储存的是点到点的距离 (即边长)
int dist[N];  //当前点到起点距离 
bool st[N];   //是否为最短路径 
int dijkstra(int a,int b){  //起点，终点
	
	memset(dist, 0x3f, sizeof dist);   //初始化用于判断是否找到
    memset(st, 0, sizeof st);
	dist[a]=0;   //第一个节点遍历同时初始化了下一层的所有节点距离
	//所以不用初始化st[1]=1 
	
	for(int i = 1; i <= n - 1; i ++ ){   //迭代一遍将所有点找到最短路径 
	//迭代次数为n-1的意思是在第n-1次时dist[n]的最短路径已经被确定 
		int  t = -1;
		for(int j = 1; j <= n; j ++){
			if(!st[j] && (t == -1 || dist[t] > dist[j])){
			//等于时不用更新 
			//找到(未找到最短路径的点)到(到起点距离(最近)的一个点 
			//该点此时到起点的距离可确定为最短路径 
				t = j;
			}
		}
		st[t]=1;  //已找到最短路径的点加入st中 
		for(int j = 1; j <= n; j ++){
			dist[j] = min(dist[j], dist[t] + g[t][j]);     //利用了贪心的思想：最短路径等于所有最短路径之和 
			//将起点到j(所有点)的距离更新为t(利用已确定最短路径的点)到j和起点到j的(较小值)
			//如果两点之间(没有联通)的话，距离应该是(无穷大)，所以起点到j的距离不变 
		}
	}
	if (dist[b] == 0x3f3f3f3f) return -1; //没找到   //注意是4个3f 
	return dist[b]; 
}

int main(){
    ios::sync_with_stdio(false);
    cin >> n >> m >> q;
     
    memset(g, 0x3f, sizeof g); 
     
    int a, b, c;
    while(m -- ){
        cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c);    
        g[b][a] = min(g[b][a], c);
    }
    while(q --){
        int op;
        cin >> op;
        if(op == 2){
            cin >> a >> b >> c;
            g[a][b] = min(g[a][b], c); 
            g[b][a] = min(g[b][a], c);          
        }
        else{
            cin >> a >> b;
            cout << dijkstra(a,b) << endl;
        }
    }
     
    return 0;
}

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
int n,m;
const int N = 1e6 + 10;
int h[N], e[N], ne[N], idx, w[N];
int dist[N];
typedef pair<int, int> PII; 
bool st[N];

void add(int a,int b,int c){
	e[idx] = b,ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
} 

int dijkstra(){
	memset(dist, 0x3f, sizeof dist);
	priority_queue<PII, vector<PII>, greater<PII> > heap;  //定义小根堆  //>>尽量不要粘在一起 
	dist[1] = 0;  //距离记得初始化 
	heap.push({0,1});   //first存储距离，second存储序号  //因为排序默认以first优先
	
	while(heap.size()){    //队列不空 
		PII t = heap.top();   //注意数据类型
		heap.pop();   //出队
		
		int distance = t.first, ver = t.second;
		
		if(st[ver]) continue;   //如果该点已经被top过(就是ver最短路径)不用再进行下一步的更新最短路径 
		st[ver] = 1;           //why？因为heap.top()是离“源点 (不断更新)”最近的点所以是最短路径 
			
		for(int i = h[ver]; i != -1; i = ne[i]){   //遍历一遍ver直接连接的点 
			int j = e[i];
			if(dist[j] > dist[ver] + w[i]) {     
				//如果当前最短路径（源点到i）大于ver到i的距离，那么更新最短路径 
				dist[j] = dist[ver] + w[i];
				heap.push({dist[j], j});     //push进去是因为只是ver是最短路径，j不一定是最短路径， 
			} 
		}
	} 
	if(dist[n] == 0x3f3f3f3f)return -1;
	return dist[n];	 
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;

#define X first
#define Y second

typedef pair<int,int> pii;
typedef long long LL;
const char nl = '\n';
const int N = 1010;
const int M = 2e5+10;
int n,m;
int g[N][N],dist[N];
bool st[N];

void dijkstra(){
	memset(dist,0x3f,sizeof dist);
	dist[1] = 0;
	for(int i = 1; i <= n - 1; i ++ ){
		int t = -1;
		for(int j = 1; j <= n; j ++){
			if(!st[j] && (t == -1 || dist[t] > dist[j]))t = j;
		}
		st[t] = 1;
		for(int j = 1; j <= n; j ++ ){
			dist[j] = min(dist[j],dist[t] + g[t][j]);
		}
	}
	cout << dist[n] << nl;
}

void solve(){
	while(~scanf("%d%d",&m,&n)){
		memset(g,0x3f,sizeof g);
		memset(st,0,sizeof st);
		while(m --){
			int a,b,w;
			cin >> a >> b >> w;
			g[a][b] = min(g[a][b],w);
			g[b][a] = g[a][b];
		}
		dijkstra();
	}
}

int main(){
	//ios::sync_with_stdio(false);
	//cin.tie(0),cout.tie(0);

	solve();
}