#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <cassert>
#include <climits>
using namespace std;
#define int long long

class SegmentTree {
private:
    vector<int> segment_tree;
    int N;
    function<int(int, int)> f;
    int e;

public:
    SegmentTree(int N, function<int(int, int)> f, int e, const vector<int>& lst = {})
        : N(N), f(f), e(e) {
        segment_tree.assign(2 * N, e);
        if (!lst.empty()) {
            assert((int)lst.size() <= N);
            for (int i = 0; i < (int)lst.size(); i++) {
                segment_tree[N + i] = lst[i];
            }
            for (int i = N - 1; i > 0; i--) {
                segment_tree[i] = f(segment_tree[i << 1], segment_tree[i << 1 | 1]);
            }
        }
    }

    int operator[](int i) const {
        if (i < -N || i >= N) {
            throw out_of_range("list index out of range");
        }
        if (i < 0) i += 2 * N;
        return segment_tree[i + N];
    }

    void set(int i, int x) {
        if (i < -N || i >= N) {
            throw out_of_range("list index out of range");
        }
        if (i < 0) i += 2 * N;
        i += N;
        segment_tree[i] = x;
        while (i > 1) {
            i >>= 1;
            segment_tree[i] = f(segment_tree[i << 1], segment_tree[i << 1 | 1]);
        }
    }

    int fold(int L = 0, int R = -1) const {
        if (R == -1) R = N;
        L += N;
        R += N;
        int vL = e, vR = e;
        while (L < R) {
            if (L & 1) vL = f(vL, segment_tree[L++]);
            if (R & 1) vR = f(segment_tree[--R], vR);
            L >>= 1;
            R >>= 1;
        }
        return f(vL, vR);
    }

    int bisect_left(int R, function<bool(int)> check) const {
        if (R == 0) return 0;
        R += N;
        int v = e;
        while (R > 1) {
            R--;
            while (R > 1 && (R % 2 == 0)) R >>= 1;
            int vv = f(segment_tree[R], v);
            if (check(vv)) {
                v = vv;
            } else {
                while (R < N) {
                    R = R * 2 + 1;
                    vv = f(segment_tree[R], v);
                    if (check(vv)) {
                        v = vv;
                        R--;
                    }
                }
                return R + 1 - N;
            }
        }
        return 0;
    }
};

signed main() {
    string S;
    cin >> S;
    int N = S.size();
    const int inf = INT_MAX;
    SegmentTree ST(N + 1, [](int a, int b) { return min(a, b); }, inf);

    vector<int> queue = {0};
    ST.set(0, 0);
    long long ans = 0;
    const int M = 200000;
    vector<vector<int>> lst(2 * M + 10);
    lst[M].push_back(0);

    for (int i = 0; i < N; i++) {
        char s = S[i];
        if (s == '(') {
            queue.push_back(queue.back() + 1);
            lst[queue.back() + M].push_back(queue.size() - 1);
            ST.set(queue.size() - 1, queue.back());
        } else if (s == ')') {
            queue.push_back(queue.back() - 1);
            lst[queue.back() + M].push_back(queue.size() - 1);
            ST.set(queue.size() - 1, queue.back());
            int l = ST.bisect_left(queue.size(), [&](int x) { return x >= queue.back(); });
            ans += lst[queue.back() + M].size() - 
                   (lower_bound(lst[queue.back() + M].begin(), lst[queue.back() + M].end(), l) - lst[queue.back() + M].begin()) - 1;
        } else {
            int l = ST.bisect_left(queue.size(), [&](int x) { return x >= queue.back(); });
            ans -= lst[queue.back() + M].size() - 
                   (lower_bound(lst[queue.back() + M].begin(), lst[queue.back() + M].end(), l) - lst[queue.back() + M].begin()) - 1;
            lst[queue.back() + M].pop_back();
            ST.set(queue.size() - 1, inf);
            queue.pop_back();
        }
        cout << ans << '\n';
    }

    return 0;
}