#include <iostream>
#include <algorithm>
using namespace std;

int n,m;
int* a;
unsigned long long* d;
unsigned long long* b;

class Node;

Node** bisectionArray;
int bcounter = 0;
int bcounter1 = 0;

class Node{

public:
	Node(Node* f, unsigned long long lI, unsigned long long rI){
		leftIndex = lI;
		rightIndex = rI;
		father = f;

		lastHarvest = 0;
		minusValue = 0;
		minusValueWhen = 0;

		if(rightIndex - leftIndex != 0){
			leftChild = new Node(this, leftIndex, leftIndex + (rightIndex-leftIndex)/2);
			rightChild = new Node(this, leftIndex + (rightIndex-leftIndex)/2 + 1, rightIndex);
		}
		else
		{
			leftChild = NULL;
			rightChild = NULL;

			bisectionArray[bcounter] = this;
			bcounter++;
		}
	}

	unsigned long long fillGrowthRates()
	{
		if (leftChild != NULL)
		{
			growthRate = leftChild->fillGrowthRates() + rightChild->fillGrowthRates();
		}
		else 
		{
			growthRate = a[bcounter1];
			bcounter1++;
		}

	    return growthRate;
	}

	int getLastHarvest()
	{
		if (father != NULL)
		{
			return std::max(lastHarvest, father->getLastHarvest());
		}
		else 
		{
			return lastHarvest;
		}
	}

	bool canBeHarvested(int harvestNumber)
	{
		unsigned long long lh = getLastHarvest();
		unsigned long long daysPassed = d[harvestNumber] - d[lh];

		unsigned long long grassLevel = b[lh] + daysPassed * growthRate;

		if(grassLevel > b[harvestNumber])
			return true;

		return false;
	}

	unsigned long long harvest(int harvestNumber)
	{
		//cout<<"Harvesting "<<leftIndex<< " "<<rightIndex<<endl;

		unsigned long long lh = getLastHarvest();
		unsigned long long daysPassed = d[harvestNumber] - d[lh];

		unsigned long long grassLevel = b[lh]*(rightIndex - leftIndex + 1) + daysPassed * growthRate;
		//cout<<"Grass "<<grassLevel<<endl;

		unsigned long long result = grassLevel - b[harvestNumber] * (rightIndex - leftIndex + 1);
		unsigned long long result1 = result;
		if(minusValueWhen>lh){
			result-=minusValue;
			if (father != NULL)
				father->fixMinusValueUp(minusValue);
		}
		minusValue = 0;

		if(father != NULL)
		{
			father->setMinusValueUp(result1, harvestNumber);
		}


		lastHarvest = harvestNumber;
		return result;
	}

	void fixMinusValueUp(unsigned long long result)
	{
		minusValue -= result;
		if(father != NULL)
		{
			father->fixMinusValueUp(result);
		}
	}

	void setMinusValueUp(unsigned long long result, int harvestNumber)
	{	
		if(minusValueWhen<getLastHarvest())
		{
			minusValue = 0;
		}
		minusValue+= result;
		minusValueWhen = harvestNumber;

		if(father != NULL)
		{
			father->setMinusValueUp(result, harvestNumber);
		}
	}




	Node* father;
	Node* leftChild;
	Node* rightChild;


	unsigned long long leftIndex;
	unsigned long long rightIndex;

	int lastHarvest;

	unsigned long long minusValue;
	unsigned long long minusValueWhen;
	unsigned long long growthRate;
};

Node* root;


void createTree()
{
	bisectionArray = new Node*[n];
	root = new Node(NULL, 0, n-1);

	root->fillGrowthRates();
}

Node* bisection(int start, int end, int harvestNumber)
{
	//cout<<"bisection: "<<start<<" "<<end<<endl;
	if(start>end) return NULL;

	if(start == 0 && ((start==end)||(end == 1)))
	{
		if(bisectionArray[0]->canBeHarvested(harvestNumber))
			return bisectionArray[0];
		else
			return NULL;
	}

	int separator = start + (end-start)/2;

	if (bisectionArray[separator]->canBeHarvested(harvestNumber))
	{	
		if(!bisectionArray[separator-1]->canBeHarvested(harvestNumber))
			return bisectionArray[separator];
		else
			return bisection(start, separator-1, harvestNumber);
	}
	else 
	{
		return bisection(separator+1, end, harvestNumber);
	}
}

unsigned long long harvest(Node* whereTo, int harvestNumber)
{
	//find base node
	while(whereTo->father != NULL && (whereTo == whereTo->father->leftChild))
	{
		whereTo = whereTo->father;
	}

	unsigned long long result = 0;
	result = whereTo->harvest(harvestNumber);
	whereTo = whereTo->father;

	if(whereTo == NULL)
		return result;

	while(whereTo->father != NULL)
	{
		if(whereTo->father->leftChild == whereTo)
		{
			result += whereTo->father->rightChild->harvest(harvestNumber);
		}

		whereTo = whereTo->father;
	}
	return result;
}



int main()
{
	std::ios_base::sync_with_stdio(false);
	cin>>n>>m;
	a = new int[n];
	
	for(int k=0;k<n;k++)
	{
		cin>>a[k];
	}
	std::sort(a, a+n);

	createTree();
	b = new unsigned long long[m+1];
	d = new unsigned long long[m+1];
	b[0] = 0;
	d[0] = 0;
	for(int k=1;k<=m;k++)
	{
		cin>>d[k]>>b[k];

		Node* whereTo = bisection(0, n-1, k);

		if(whereTo == NULL)
		{
			cout<<0<<endl;
		}
		else
		{
			cout<<harvest(whereTo, k)<<endl;
		}
	}
	return 0;
}