#include <bits/stdc++.h>
using namespace std;
using ll = unsigned long long;

int n, m;

class SetTree {
private :
	int n; // new array
	vector<ll> tree; // Tree
	vector<ll> lazy; // lazy flag
	
	void build(const vector<int> &data, int node, int start, int end) {
		// each node's number
		if (start == end) {
			tree[node] = data[start];
			return;
		}
		
		int mid = (start + end) >> 1;
		int left_node = 2 * node + 1;
		int right_node = 2 * node + 2;
		
		build(data, left_node, start, mid);
		build(data, right_node, mid + 1, end);
		
		tree[node] = tree[left_node] + tree[right_node];
	}
	
	// lazy flag
	void push_down(int node, int start, int end) {
		if (lazy[node] != 0) {
			int mid = (start + end) >> 1;
			int left_node = node * 2 + 1;
			int right_node = node * 2 + 2;
			int left_length = mid - start + 1;
			int right_length = end - mid;
			
			// left tree
			tree[left_node] += lazy[node] * left_length;
			lazy[left_node] += lazy[node];
			
			//right tree
			tree[right_node] += lazy[node] * right_length;
			lazy[right_node] += lazy[node];
			
			lazy[node] = 0;
		}
	}
	
	void update_range(int node, int start, int end, int l, int r, int val) {
		// now range really not in new range
		if (r < start || l > end) return ;
		
		// now range in new range
		if (l <= start && end <= r) {
			tree[node] += val * (end - start + 1);
			lazy[node] += val;
			return ;
		}
		
		// now range not really in new range
		push_down(node, start, end);
		
		int mid = (start + end) >> 1;
		int left_node = node * 2 + 1;
		int right_node = node * 2 + 2;
		
		update_range(left_node, start, mid, l, r, val);
		update_range(right_node, mid + 1, end, l, r, val);
		
		tree[node] = tree[left_node] + tree[right_node];
	}
	
	ll query_range(int node, int start, int end, int l, int r) {
		if (r < start || l > end) return 0;
		
		if (l <= start && end <= r) return tree[node];
		
		push_down(node, start, end);
		
		int mid = (start + end) >> 1;
		int left_node = node * 2 + 1;
		int right_node = node * 2 + 2;
		
		ll left_sum = query_range(left_node, start, mid, l, r);
		ll right_sum = query_range(right_node, mid + 1, end, l, r);
		
		return left_sum + right_sum;
	}

public :
	SetTree(const vector<int> &data) : n(data.size()) {
		tree.resize(4 * n, 0);
		lazy.resize(4 * n, 0);
		build(data, 0, 0, n - 1);
	}
	
	void update(int l, int r, ll val) {
		update_range(0, 0, n - 1, l, r, val);
	}
		
	
	ll query(int l, int r) {
		return query_range(0, 0, n - 1, l, r);
	}
};

int main() {
	scanf("%d %d", &n, &m);
	vector<int> data(n);
	for (int i = 0; i < n; i ++) scanf("%d", &data[i]);
	
	SetTree st(data);
	
	while (m --) {
		int o; scanf("%d", &o);
		if (o == 1) {
			int x, y, k; scanf("%d %d %d", &x, &y, &k);
			-- x, -- y; // because vector from zero
			st.update(x, y, k);
		}
		else if (o == 2) {
			int x, y; scanf("%d %d", &x, &y);
			-- x, -- y;
			printf("%lld\n", st.query(x, y));
		}
	}
	
	return 0;
}