The Smart Beaver from ABBYY began to develop a new educational game for children. The rules of the game are fairly simple and are described below.

The playing field is a sequence of n non-negative integers ai numbered from 1 to n. The goal of the game is to make numbers a1, a2, ..., ak (i.e. some prefix of the sequence) equal to zero for some fixed k (k < n), and this should be done in the smallest possible number of moves.

One move is choosing an integer i (1 ≤ i ≤ n) such that ai > 0 and an integer t (t ≥ 0) such that i + 2t ≤ n. After the values of i and t have been selected, the value of ai is decreased by 1, and the value of ai + 2t is increased by 1. For example, let n = 4 and a = (1, 0, 1, 2), then it is possible to make move i = 3, t = 0 and get a = (1, 0, 0, 3) or to make move i = 1, t = 1 and get a = (0, 0, 2, 2) (the only possible other move is i = 1, t = 0).

You are given n and the initial sequence ai. The task is to calculate the minimum number of moves needed to make the first k elements of the original sequence equal to zero for each possible k (1 ≤ k < n).

Input

The first input line contains a single integer n. The second line contains n integers ai (0 ≤ ai ≤ 104), separated by single spaces.

The input limitations for getting 20 points are: 

  * 1 ≤ n ≤ 300



The input limitations for getting 50 points are: 

  * 1 ≤ n ≤ 2000



The input limitations for getting 100 points are: 

  * 1 ≤ n ≤ 105

Output

Print exactly n - 1 lines: the k-th output line must contain the minimum number of moves needed to make the first k elements of the original sequence ai equal to zero.

Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams, or the %I64d specifier.

Examples

Input

4
1 0 1 2


Output

1
1
3


Input

8
1 2 3 4 5 6 7 8


Output

1
3
6
10
16
24
40
#include <bits/stdc++.h>
using namespace std;
struct edge {
  int to;
  int next;
  int num;
} e[3][100010 << 1];
int box[3][100010], cnt[3];
void init() {
  memset(box, -1, sizeof(box));
  memset(cnt, 0, sizeof(cnt));
}
void add(int from, int to, int num, int t) {
  e[t][cnt[t]].to = to;
  e[t][cnt[t]].num = num;
  e[t][cnt[t]].next = box[t][from];
  box[t][from] = cnt[t]++;
}
int pre[100010];
int low[100010];
int bridge[100010];
int bcnt = 0;
int cnt0;
void bridge_search(int now, int fa) {
  int t;
  int v, w;
  low[now] = pre[now] = ++cnt0;
  for (t = box[0][now]; t + 1; t = e[0][t].next) {
    v = e[0][t].to;
    if (v == fa) continue;
    if (!pre[v]) {
      bridge_search(v, now);
      if (low[v] < low[now]) low[now] = low[v];
      if (low[v] > pre[now]) {
        bridge[e[0][t].num] = 1;
      }
    } else {
      if (low[now] > pre[v]) low[now] = pre[v];
    }
  }
}
int Bridge(int n) {
  int i;
  cnt0 = 0;
  memset(pre, 0, sizeof(pre));
  memset(low, 0, sizeof(low));
  memset(bridge, 0, sizeof(bridge));
  bcnt = 0;
  for (i = 1; i <= n; i++) {
    if (!pre[i]) {
      bridge_search(i, 0);
    }
  }
  return bcnt;
}
int vis[100010];
int dist[100010];
void Dfs(int now, int num) {
  low[now] = num;
  vis[now] = 1;
  int t, v, nn;
  for (t = box[0][now]; t + 1; t = e[0][t].next) {
    v = e[0][t].to, nn = e[0][t].num;
    if (bridge[nn]) continue;
    if (!vis[v]) {
      Dfs(v, num);
    }
  }
}
void solve(int n) {
  int i, sum = 0;
  memset(low, 0, sizeof(low));
  memset(vis, 0, sizeof(vis));
  for (i = 1; i <= n; i++) {
    if (!low[i]) Dfs(i, ++sum);
  }
  for (i = 1; i <= n; i++) {
    int t, v;
    for (t = box[0][i]; t + 1; t = e[0][t].next) {
      v = e[0][t].to;
      if (low[i] != low[v]) {
        add(low[i], low[v], 0, 1);
        add(low[v], low[i], 0, 1);
      }
    }
  }
}
void dfs(int now, int deep) {
  dist[now] = deep;
  vis[now] = 1;
  int t, v;
  for (t = box[1][now]; t + 1; t = e[1][t].next) {
    v = e[1][t].to;
    if (!vis[v]) {
      dfs(v, deep + 1);
    }
  }
}
int f[100010];
void finit(int n) {
  int i;
  for (i = 0; i <= n; i++) f[i] = i;
}
int find(int x) {
  if (x == f[x]) return x;
  return f[x] = find(f[x]);
}
int ans[100010];
void lca(int now) {
  f[now] = now;
  vis[now] = 1;
  int t, v, x;
  for (t = box[1][now]; t + 1; t = e[1][t].next) {
    v = e[1][t].to;
    if (!vis[v]) {
      lca(v);
      f[v] = now;
    }
  }
  for (t = box[2][now]; t + 1; t = e[2][t].next) {
    v = e[2][t].to, x = e[2][t].num;
    if (vis[v] == 2) {
      int tt = find(v);
      ans[x] = dist[now] + dist[v] - 2 * dist[tt];
    }
  }
  vis[now] = 2;
}
int main() {
  int n, m, i, a, b, q;
  scanf("%d%d", &n, &m);
  init();
  for (i = 1; i <= m; i++) {
    scanf("%d%d", &a, &b);
    add(a, b, i, 0);
    add(b, a, i, 0);
  }
  memset(ans, 0, sizeof(ans));
  Bridge(n);
  solve(n);
  memset(vis, 0, sizeof(vis));
  dfs(1, 0);
  scanf("%d", &q);
  for (i = 1; i <= q; i++) {
    scanf("%d%d", &a, &b);
    if (low[a] != low[b]) {
      add(low[a], low[b], i, 2);
      add(low[b], low[a], i, 2);
    }
  }
  memset(vis, 0, sizeof(vis));
  lca(1);
  for (i = 1; i <= q; i++) printf("%d\n", ans[i]);
  return 0;
}
