#include <iostream>

#include <vector>

#include <algorithm>

#include <cmath>

using namespace std;

bool isPower(long long n)

{

    long long f = 1;

    while (f <= n) {

        if (f == n) {

            return false;

        }

        else {

            f *= 2;

        }

    }

    return true;

}

int main()

{

    long long n;

    long long t;

    cin >> n >> t;

    vector<unsigned long long>v(n * 2);

    long long k;

    for (long long i = n; i < n*2; i++) {

        cin >> k;

        v[i] = k;

    }

    for (long long i = n - 1; i > 0; i--) {

        v[i] = v[2 * i] + v[2 * i + 1];

    }

    unsigned long long i;

    unsigned long long j;

    unsigned long long x = 1;

    unsigned long long sum = 0;

    unsigned long long sum1 = 0;

    long long zz;

    for (long long l = 0; l < t; l++) {

        sum = 0;

        x = 1;

        sum1 = 0;

        cin >> i;

        cin >> j;

        i += n - 1;

        j += n - 1;

        zz = i;

        if (i == j) {

            cout << v[j] << endl;

        }

        else {

            while (isPower(i)) {

                if ((i) % 2 == 0) {

                    sum += v[i];

                    i = i * x - 1;

                    x = 1;

                }

                else {

                    x = x * 2;

                    i = i / 2;

                }

            }

            sum += v[i];

            x = 1;

            while (isPower(j)) {

                if (j % 2 == 0) {

                    sum1 += v[j];

                    j = j * x - 1;

                    x = 1;

                }

                else {

                    x = x * 2;

                    j = j / 2;

                }

            }

            sum1 += v[j];

            cout << (sum1 - sum + v[zz])% 9223372036854775807 << endl;

        }

    }

}

void build(int node, int start, int end)

{

    if(start == end)

    {

        // Leaf node will have a single element

        tree[node] = A[start];

    }

    else

    {

        int mid = (start + end) / 2;

        // Recurse on the left child

        build(2*node, start, mid);

        // Recurse on the right child

        build(2*node+1, mid+1, end);

        // Internal node will have the sum of both of its children

        tree[node] = tree[2*node] + tree[2*node+1];

    }

}

#define _USE_MATH_DEFINES

#include <bits/stdc++.h>

​

using namespace std;

​

class Node {

public:

    int data, iL, iR;

    Node* left;

    Node* right;

​

    Node(int iL, int iR): iL(iL), iR(iR) {}

};

​

​

Node* constructTree(vector<int> arr, int start, int end) {

    if (start == end) {

        Node* leaf = new Node(start, end);

        leaf->data = arr[start];

        return leaf;

    }

    Node* node = new Node(start, end);

    int mid = (start + end) / 2;

    node->left = constructTree(arr, start, mid);

    node->right = constructTree(arr, mid + 1, end);

    node->data = node->left->data + node->right->data;

    return node;

}

​

void display(Node* node) {

    if (node->iL == node->iR) {

        cout << node->data << " ";

        return;

    }

    display(node->left);

    display(node->right);

}

​

int query(Node* node, int indL, int indR) {

    if (node->iL >= indL && node->iR <= indR) {

        return node->data;

    }

    else if (node->iL > indR || node->iR < indL)

        return 0;

    else {

        return (query(node->left, indL, indR) + query(node->right, indL, indR));

    }

}

​

int updateVal(Node* root, int index, int val) {

    if (index >= root->iL && index <= root->iR) {

        if (index == root->iL && index == root->iR) {

            root->data = val;

        }

        else {

            int leftSum = updateVal(root->left, index, val);

            int rightSum = updateVal(root->right, index, val);

            root->data = leftSum + rightSum;

        }

    }

    return root->data;

}

​

int main()

{

    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    vector<int> v = {3, 8, 6, 7, -2, -8, 4, 9};

    Node* root1 = constructTree(v, 0, v.size() - 1);

    cout << query(root1, 1, 6);

    return 0;

}

class SGTree

{

    vector<int> seg;

​

public:

    SGTree(int n)

    {

        seg.resize(4 * n + 1);

    }

    void build(int ind, int low, int high, int arr[])

    {

        if (low == high)

        {

            seg[ind] = arr[low];

            return;

        }

        int mid = (low + high) / 2;

        build(2 * ind + 1, low, mid, arr);

        build(2 * ind + 2, mid + 1, high, arr);

        seg[ind] = min(seg[2 * ind + 1], seg[2 * ind + 2]);

    }

​

    int query(int ind, int low, int high, int l, int r)

    {

        // no overlap

        if (r < low || high < l)

            return INT_MAX;

​

        // complete overlap

        if (low >= l && high <= r)

            return seg[ind];

​

        // partial overlap

        int mid = (low + high) >> 1;

        int left = query(2 * ind + 1, low, mid, l, r);

        int right = query(2 * ind + 2, mid + 1, high, l, r);

        return min(left, right);

    }

​

    void update(int ind, int low, int high, int i, int val)

    {

        if (low == high)

        {

            seg[ind] = val;

        }

        int mid = (low + high) >> 1;

        if (i <= mid)

            update(2 * ind + 1, low, mid, i, val);

        else

            update(2 * ind + 2, mid + 1, high, i, val);

        seg[ind] = min(seg[2 * ind + 1], seg[2 * ind + 2]);

    }

};