public class Main {
    static int N, M, K;

    
    static class SegmentTree {
	long[] tree;
	long[] origArr;
	int size;
	
	public SegmentTree(long[] nums) {
	    origArr=nums;
	    size=nums.length;
	    tree=new long[4*size];
	    build(1,0,size-1);
	}
	
	long build(int node, long start, long end) {
	    if(start==end) {
		return tree[node]=origArr[(int) start];
	    }
	    
	    int mid=(int) ((start+end)/2);
	    long leftsum=build(node*2,start,mid);
	    long rightsum=build(node*2+1,mid+1,end);
	    return tree[node]=leftsum+rightsum;
	}
	
	long query(int node, int start, int end,long left, long right) {
	    if(start>right || end<left) {
		return 0;
	    }
	    
	    if(left<=start && end<=right) {
		return tree[node];
	    }
	    
	    int mid=(start+end)/2;
	    long leftsum=query(node*2,start,mid,left,right);
	    long rightsum=query(node*2+1,mid+1,end,left,right);
	    
	    return leftsum+rightsum;
	}
	
	void update(int node, int start, int end, long idx, long val) {
	    if(idx<start || idx>end) {
		return;
	    }
	    if(start==end) {
		
		tree[node]=val;
		origArr[(int) idx]=val;
		return;
		
	    }
	    int mid=(start+end)/2;
	    if(idx<=mid) {
		update(node*2,start,mid,idx,val);
	    } else {
		update(node*2+1,mid+1,end,idx,val);
	    }
	    
	    tree[node]=tree[node*2]+tree[node*2+1];
	    
	    
	}
	
	
    }

    public static void main(String[] args) throws Exception {

       
        //System.setIn(new FileInputStream("input.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());

        long[] nums = new long[N];

        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            nums[i] = Long.parseLong(st.nextToken());
        }

     
        SegmentTree stree = new SegmentTree(nums);
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < M + K; i++) {
            st = new StringTokenizer(br.readLine());
            int A = Integer.parseInt(st.nextToken());
            long B = Long.parseLong(st.nextToken());
            long C = Long.parseLong(st.nextToken()); 

            switch (A) {
                case 1: {
                    
                    stree.update(1, 0, N - 1, B - 1, C);
                    break;
                }
                case 2: {
                    
                    long qSum = stree.query(1, 0, N - 1, B - 1, C - 1);
                    
                    sb.append(qSum).append("\n");
                    break;
                }
            }
        }

        System.out.print(sb.toString());
    }
}

public class Main {
	public static class Node {
		int to;
		int val;
		public Node(int t, int v) {
			to=t;
			val=v;
		}
	}

	public static void main(String args[]) throws Exception {
		
		//System.setIn(new FileInputStream("res/input.txt"));
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer st=new StringTokenizer(br.readLine());
		int N=Integer.parseInt(st.nextToken());
		st=new StringTokenizer(br.readLine());
		int M=Integer.parseInt(st.nextToken());
		List<List<Node>> g=new ArrayList<>();
		int[] dist=new int[N+1];
		Arrays.fill(dist,Integer.MAX_VALUE);
		
		
		
		for(int i=0;i<=N;i++) {
			g.add(new ArrayList<>());
		}
		
		
		for(int i=0;i<M;i++) {
			st=new StringTokenizer(br.readLine());
			int f=Integer.parseInt(st.nextToken());
			int t=Integer.parseInt(st.nextToken());
			int v=Integer.parseInt(st.nextToken());
			g.get(f).add(new Node(t,v));
		}
			
		st=new StringTokenizer(br.readLine());
		int sIdx=Integer.parseInt(st.nextToken());
		int eIdx=Integer.parseInt(st.nextToken());
		
		PriorityQueue<Node> q=new PriorityQueue<>((o1,o2)->{
			if(o1.val<o2.val) {
				return -1;
			} else if(o1.val>o2.val) {
				return 1;
			} else return 0;
		});
		
		dist[sIdx]=0;
		q.add(new Node(sIdx,0));
		
		while(!q.isEmpty()) {
			Node curr=q.poll();
			
			if(dist[curr.to]<curr.val) {
				continue;
			}
			
			for(Node next:g.get(curr.to)) {
				if(dist[next.to]>dist[curr.to]+next.val) {
					dist[next.to]=dist[curr.to]+next.val;
					q.add(new Node(next.to,dist[next.to]));
				}
			}
			
		} //while문 끝
		
		System.out.println(dist[eIdx]);
		
		
		
		
	}
}