#if 0

Mo
係数 : 2

#endif
// includes {{{
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
// #include<deque>
// #include<multiset>
// #include<cstring>
// #include<bits/stdc++.h>
// }}}
using namespace std;
using ll = int;

#ifndef DEBUG
#define NDEBUG
#endif

// .add(i, v)   : bit[i] += v
// .get(i)      : bit[i]
// .sum(i)      : bit[0] + ... + bit[i]
// .range(l, r) : bit[l] + ... + bit[r]
// .lower_bound(T v) : min i that satisfies .sum(i) >= v
//    - use only when bit[i] >= 0 for all i > 0
/// --- Binary Indexed Tree {{{ ///
#include <cassert>
#include <vector>
template < class T = long long >
struct BinaryIndexedTree {
  using size_type = std::size_t;
  size_type n, m;
  T identity;
  std::vector< T > data;
  BinaryIndexedTree() : n(0) {}
  BinaryIndexedTree(int n, T identity = T())
      : n(n), identity(identity), data(n, identity) {
    m = 1;
    while(m < n) m <<= 1;
  }
  void add(size_type i, T x) {
    assert(i < n);
    i++;
    while(i <= n) {
      data[i - 1] = data[i - 1] + x;
      i += i & -i;
    }
  }
  T sum(int i) {
    if(i < 0) return identity;
    if(i >= n) i = n - 1;
    i++;
    T s = identity;
    while(i > 0) {
      s = s + data[i - 1];
      i -= i & -i;
    }
    return s;
  }
  T get(int i) { return sum(i) - sum(i - 1); }
  T range(int a, int b) {
    if(a > b) return identity;
    return sum(b) - sum(a - 1);
  }
  size_type lower_bound(T w) {
    size_type i = 0;
    for(size_type k = m; k > 0; k >>= 1) {
      if(i + k <= n && data[i + k - 1] < w) w -= data[(i += k) - 1];
    }
    return i;
  }
};
/// }}}--- ///

template < class T = long long >
using BIT = BinaryIndexedTree< T >;

// Mo(N, JUST Q, double k)
// favored : k = 2
// 1: insert
// 2: build
/// --- Mo Library {{{ ///

struct Mo {
  const int width;
  int q = 0;
  vector< int > le, ri, order;
  int nl = 0, nr = 0;
  Mo(int n, int q, double k = 1)
      : width(int(k* n / sqrt(q) + 1.0)), le(q), ri(q), order(q) {}
  inline void insert(int l, int r) {
    le[q] = l;
    ri[q] = r;
    order[q] = q;
    q++;
  }
  inline void build() {
    sort(begin(order), begin(order) + q, [&](int a, int b) {
      const int ab = le[a] / width, bb = le[b] / width;
      return ab != bb ? ab < bb : ab & 1 ? ri[a] < ri[b] : ri[b] < ri[a];
    });
    nl = nr = le[order[0]];
    for(int i = 0; i < q; i++) {
      const int id = order[i];
      while(nl > le[id]) add(--nl);
      while(nl < le[id]) rem(nl++);
      while(nr < ri[id]) add(nr++);
      while(nr > ri[id]) rem(--nr);
      next(id);
    }
  }
  inline void next(int i);
  inline void add(int i);
  inline void rem(int i);
};

/// }}}--- ///

constexpr int N = 1e5;
constexpr int Q = 1e5;
int n, q;
int a[N];
int l[Q], r[Q];
int ord[N];
int rnk[N];
ll ans[Q];

BIT< int > cnt(N);
BIT< ll > d(N);

inline void Mo::next(int i) {
  int len = r[i] - l[i];
  int x = cnt.lower_bound((len + 1) / 2);
  assert(cnt.sum(n - 1) == len);
  if(len % 2 == 0) {
    ans[i] = -d.sum(x) + d.range(x + 1, n - 1);
  } else {
    ans[i] = -d.sum(x - 1) + d.range(x + 1, n - 1);
  }
}
inline void Mo::add(int i) {
  cnt.add(rnk[i], 1);
  d.add(rnk[i], a[i]);
}
inline void Mo::rem(int i) {
  cnt.add(rnk[i], -1);
  d.add(rnk[i], -a[i]);
}

int main() {
  std::ios::sync_with_stdio(false), std::cin.tie(0);
  cin >> n >> q;

  Mo mo(n, q, 2);

  assert(1 <= n and n <= int(1e5));
  assert(1 <= q and q <= int(1e5));

  vector< pair< ll, int > > v;

  for(int i = 0; i < n; i++) {
    cin >> a[i], v.emplace_back(a[i], i);
    assert(int(-1e9) <= a[i] and a[i] <= int(1e9));
  }

  iota(ord, ord + n, 0);
  sort(ord, ord + n, [&](int i, int j) { return a[i] < a[j]; });
  for(int i = 0; i < n; i++) rnk[ord[i]] = i;

  for(int i = 0; i < q; i++) {
    cin >> l[i] >> r[i];
    assert(1 <= l[i] and l[i] <= r[i] and r[i] <= n);
    l[i]--;
    mo.insert(l[i], r[i]);
  }

  mo.build();

  for(int i = 0; i < q; i++) cout << ans[i] << "\n";
  return 0;
}