#define _GLIBCXX_DEBUG                                              
#include <bits/stdc++.h>
using namespace std;
 
mt19937 rng(450);

using ll = long long;
 
struct node
{
	int l, r;
	int y;

	int cnt;

	ll sum;
	int val;

	/// можно добавить какую-нибудь информацию в каждую вершину
	node() : l(-1), r(-1), y(-1), cnt(-1), sum(0), val(0) {} ///val(-1) {}
 
	node(const int val_) : l(-1), r(-1), y(rng()), cnt(1), sum(val_), val(val_) {} ///val(val_) {}
};
 
struct treap_manager
{
	vector<node> v;
 
	pair<int, int> split (const int t, const int k)
	{
		if (t == -1)
			return pair<int, int>(-1, -1);
 
		if (cnt(v[t].l) >= k)
		{
			///int l, r;
			///pair<int, int> p = split(v[t].l, x0);
			///l = p.first; r = p.second;
			auto [l, r] = split(v[t].l, k);
			v[t].l = r;
			recalc(t);
			return pair<int, int>(l, t);
		}
		else
		{
			auto [l, r] = split(v[t].r, k - cnt(v[t].l) - 1);
			v[t].r = l;
			recalc(t);
			return pair<int, int>(t, r);
		}
	}

	ll sum (const int t)
	{
		return t == -1 ? 0LL : v[t].sum;
	}

	void recalc (const int t)
	{
		if (t != -1)
		{
			v[t].cnt = cnt(v[t].l) + 1 + cnt(v[t].r);
			v[t].sum = sum(v[t].l) + v[t].val + sum(v[t].r);
		}
	}
 
	int merge (const int l, const int r)
	{
		if (l == -1)
			return r;
		if (r == -1)
			return l;
 
		if (v[l].y > v[r].y)
		{
			v[l].r = merge(v[l].r, r);
			recalc(l);
			return l;
		}
		else
		{
			v[r].l = merge(l, v[r].l);
			recalc(r);
			return r;
		}
	}

	int cnt (const int t)
	{
		return t == -1 ? 0 : v[t].cnt;
	}
 
	int newnode (const int val)
	{
		v.push_back(node(val));
		return int(v.size()) - 1;
	}
                                                                   
	void insert (int &root, const int pos, const int val)
	{
		auto [l, r] = split(root, pos);
		const int m = newnode(val);
		root = merge(merge(l, m), r);
	}	

	void remove (int &root, const int pos)	
	{
		assert(0 <= pos && pos < cnt(root));
		auto [l, temp] = split(root, pos);
		auto [m, r] = split(temp, 1);
		root = merge(l, r);
	}

	void assign (int &root, const int pos, const int val)
	{
		assert(0 <= pos && pos < cnt(root));
		auto [l, temp] = split(root, pos);
		auto [m, r] = split(temp, 1);
		v[m].val = val;
		recalc(m);
	}

	int get_kth (const int root, const int k)
	{
		assert(root != -1);
		assert(0 <= k && k < cnt(root));
		const int pivot = cnt(v[root].l);

		if (k < pivot)
			return get_kth(v[root].l, k);
		else if (k == pivot)
			return v[root].val;
		else
			return get_kth(v[root].r, k - pivot - 1);	
	}

	int get_kth_stupid (int &root, const int k)
	{
		auto [l, temp] = split(root, k);
		auto [m, r] = split(temp, 1);
		assert(m != -1);
		const int ans = v[m].val;
		root = merge(merge(l, m), r);
		return ans;
	}

	/// [lb, rb)
	ll get_sum (int &root, const int lb, const int rb)
	{
		auto [l, temp] = split(root, lb);
		auto [m, r] = split(temp, rb - lb);
		const ll ans = sum(m);
		root = merge(merge(l, m), r);
		return ans;
	}	
};
 
int main()
{
	treap_manager info;
                                  
	int n, m;
	cin >> n >> m;

	vector<int> a(n);
	for (auto &it : a)
		cin >> it;

	int root = -1;
	for (int i = n - 1; i >= 0; i--)
		info.insert(root, 0, a[i]);

	for (int i = 0; i < m; i++)
	{
		int l, r;
		cin >> l >> r;
		--l;

		cout << info.get_sum(root, l, r) << "\n";
	}	                                           
	
}