
//#pragma GCC target("avx2")
#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")

#include <bits/stdc++.h>

using namespace std;

#include <atcoder/all>
using namespace atcoder;

#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...)  cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif

void d_err() {
    cerr << endl;
}

template <typename H, typename... T>
void d_err(H h, T... t) {
    cerr << h << " ";
    d_err(t...);
}

template <typename T>
void print(T x) {
    cout << x << "\n";
}

#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (ll i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (ll i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> Pll;
typedef pair<int,int> Pin;

ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9+7;

int main(){
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(20);

    int n, q;
    cin >> n >> q;

    fenwick_tree<ll> ft(n);
    REP(i, n) {
        ll a; cin >> a;
        ft.add(i, a);
    }

    REP(i, q) {
        int t, a, b;
        cin >> t >> a >> b;
        if (t == 0) {
            ft.add(a, b);
        } else {
            print(ft.sum(a, b));
        }
    }

}

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


struct Union{
	vector<int> par;
	vector<int> size;
	

	Union(int n) : par(n), size(n,1){
	    for(int i=0; i < n; i++){
			size[i] = 1;
			par[i] = i;
		}
	}

	int find(int x){
		if (x == par[x]) return x;
		return par[x] = find(par[x]);  
	}

	void unite(int x, int y){
		x = find(x);
		y = find(y);

		if(x == y) return;

		if(size[x] < size[y]) swap(x, y);
		
		par[y] = x;
		size[x] += size[y];
	}

	bool same(int x, int y){
		return find(x) == find(y);
	}

	int getSize(int x){
		return size[find(x)];
	}
};


struct Edge{
	int a, b, cost;

	bool operator<(const Edge& o) const{
		return cost < o.cost;
	}
};


struct Graph{
	int n;  
	vector<Edge> e;  

	int kruskal(){
		sort(e.begin(), e.end());

		Union u(n);
		int min_cost = 0;

	    for(int i=0; i<e.size(); i++){
			Edge& x = e[i];
			if (u.same(x.a, x.b) == false){
				min_cost += x.cost;
				u.unite(x.a, x.b);
			}
		}

		return min_cost;
	}
};

int main(){
	Graph g;
	Edge e;
	int m;
	cin >> g.n >> m;
  
    for(int i=0; i<m; i++){	
		cin >> e.a >> e.b >> e.cost;
		g.e.push_back(e);
	}
  
	cout << g.kruskal() << endl;
  
	return 0;
}
