#include <algorithm>
#include <atcoder/all>
#include <bits/stdc++.h>
#include <chrono>
#include <cstdint>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <random>

using namespace std;
using namespace atcoder;
using namespace __gnu_pbds;
using mint = modint998244353;
// using mint = modint1000000007;

using str = string;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vl = vector<long long>;
using vvl = vector<vector<long long>>;
using vvvl = vector<vector<vector<long long>>>;
using vm = vector<mint>;
using vvm = vector<vector<mint>>;
using vvvm = vector<vector<vector<mint>>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using ll = long long;
using pd_ds_set_int = tree<int, null_type, less<int>, rb_tree_tag,
                           tree_order_statistics_node_update>;
using pd_ds_set_ll = tree<long long, null_type, less<long long>, rb_tree_tag,
                          tree_order_statistics_node_update>;
template <class T> using max_heap = priority_queue<T>;
template <class T> using min_heap = priority_queue<T, vector<T>, greater<>>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, f, n) for (int i = (int)f; i < (int)(n); i++)
#define repd(i, n, l) for (int i = (int)n; i >= (int)l; i--)
#define all(p) p.begin(), p.end()
vector<pair<int, int>> dydx{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
const ll inf = 1LL << 60;
void print() { putchar(' '); }
void print(bool a) { printf("%d", a); }
void print(int a) { printf("%d", a); }
void print(unsigned a) { printf("%u", a); }
void print(long a) { printf("%ld", a); }
void print(long long a) { printf("%lld", a); }
void print(unsigned long long a) { printf("%llu", a); }
void print(char a) { printf("%c", a); }
void print(char a[]) { printf("%s", a); }
void print(const char a[]) { printf("%s", a); }
void print(float a) { printf("%.15f", a); }
void print(double a) { printf("%.15f", a); }
void print(long double a) { printf("%.15Lf", a); }
void print(const string &a) {
    for (auto &&i : a)
        print(i);
}
template <class T> void print(const complex<T> &a) {
    if (a.real() >= 0) print('+');
    print(a.real());
    if (a.imag() >= 0) print('+');
    print(a.imag());
    print('i');
}
template <class T> void print(const vector<T> &);
template <class T, size_t size> void print(const array<T, size> &);
template <class T, class L> void print(const pair<T, L> &p);
template <class T, size_t size> void print(const T (&)[size]);
template <class T> void print(const vector<T> &a) {
    if (a.empty()) return;
    print(a[0]);
    for (auto i = a.begin(); ++i != a.end();) {
        putchar(' ');
        print(*i);
    }
}
template <class T> void print(const deque<T> &a) {
    if (a.empty()) return;
    print(a[0]);
    for (auto i = a.begin(); ++i != a.end();) {
        putchar(' ');
        print(*i);
    }
}
template <class T, size_t size> void print(const array<T, size> &a) {
    print(a[0]);
    for (auto i = a.begin(); ++i != a.end();) {
        putchar(' ');
        print(*i);
    }
}
template <class T, class L> void print(const pair<T, L> &p) {
    print(p.first);
    putchar(' ');
    print(p.second);
}
template <class T, size_t size> void print(const T (&a)[size]) {
    print(a[0]);
    for (auto i = a; ++i != end(a);) {
        putchar(' ');
        print(*i);
    }
}
template <class T> void print(const T &a) { cout << a; }
constexpr ll ten(int n) { return n == 0 ? 1 : ten(n - 1) * 10; }

bool MASKI(int mask, int i) { return (mask >> i) & 1; }

bool MASKL(ll mask, int i) { return (mask >> (ll)i) & 1; }

template <typename T> vector<T> compress_coordinate(vector<T> &A) {
    int n = A.size();
    vector<T> B(n);
    rep(i, n) B[i] = A[i];
    sort(B.begin(), B.end());
    B.erase(unique(B.begin(), B.end()), B.end());
    return B;
}

vector<vector<int>> unweighted_graph(int n, int m) {
    vector<vector<int>> ret(n);
    while (m--) {
        int a, b;
        cin >> a >> b;
        a--;
        b--;
        ret[a].push_back(b);
        ret[b].push_back(a);
    }
    return ret;
}
vector<vector<pair<int, long long>>> weighted_graph(int n, int m) {
    vector<vector<pair<int, long long>>> ret(n);
    while (m--) {
        int a, b;
        long long c;
        cin >> a >> b >> c;
        a--, b--;
        ret[a].push_back({b, c});
        ret[b].push_back({a, c});
    }
    return ret;
}

template <typename T> int argmin(vector<T> &a) {
    T mi = *min_element(all(a));
    for (int i = 0; i < a.size(); i++) {
        if (a[i] == mi) return i;
    }
}

template <typename T> int argmax(vector<T> &a) {
    T ma = *max_element(all(a));
    for (int i = 0; i < a.size(); i++) {
        if (a[i] == ma) return i;
    }
}

ll op(ll a, ll b) { return a + b; }
ll e() { return 0; }

int main() {
    int N, Q;
    cin >> N >> Q;
    vl A(N);
    rep(i, N) cin >> A[i];
    // segtree<ll, op, e> seg(N);
    // fenwick_tree<ll>
    vector<vector<ll>> zeros(27, vl(N, 0)), ones(27, vl(N, 0));
    rep(i, N) {
        rep(k, 27) {
            if (A[i] & (1LL << k)) {
                ones[k][i] = 1;
            } else {
                zeros[k][i] = 1;
            }
        }
    }

    vvl cum_zeros(27, vl(N, 0)), cum_ones(27, vl(N, 0));
    rep(k, 27) {
        cum_zeros[k][0] = zeros[k][0];
        cum_ones[k][0] = ones[k][0];
        rep2(i, 1, N) {
            cum_zeros[k][i] = cum_zeros[k][i - 1] + zeros[k][i];
            cum_ones[k][i] = cum_ones[k][i - 1] + ones[k][i];
        }
    }

    vvl segs_zero(27, vl(N, 0)), segs_one(27, vl(N, 0));
    while (Q--) {
        int L, R;
        cin >> L >> R;
        L--;
        ll ans = 0;
        rep(k, 27) {
            ll zero = cum_zeros[k][R - 1];
            if (L > 0) zero -= cum_zeros[k][L - 1];
            ll one = cum_ones[k][R - 1];
            if (L > 0) one -= cum_ones[k][L - 1];
            if (zero == 0 || one == 0) continue;
            ans += (1LL << k) * zero * one;
        }
        cout << ans << "\n";
    }
    return 0;
}