#include <algorithm>
#include <array>
#include <cassert>
#include <cstdint>
#include <functional>
#include <iostream>
#include <numeric>
#include <vector>

// ans[i][j] = high score after i mult and j add cards
using State = std::vector<std::vector<int64_t>>;

// Given arrays a, b where b is concave, return the (max, +)-convolution of a and b
std::vector<int64_t> merge(const std::vector<int64_t>& a, const std::vector<int64_t>& b) {
    // aStart, bStart, offset
    using Segment = std::array<int64_t, 3>;

    auto eval = [&b](const Segment& seg, int64_t x) -> int64_t {
        int64_t offset = x - seg[0];
        assert(0 <= seg[1] + offset && seg[1] + offset < b.size());
        return b[seg[1] + offset] + seg[2];
    };

    auto endIndex = [&b](const Segment& seg) -> int64_t {
        return seg[0] + (b.size() - seg[1]);
    };

    std::vector<Segment> stk;
    for (int64_t i = 0; i < std::ssize(a); ++i) {
        Segment seg{i + 1, 0, a[i]};

        while (!stk.empty()) {
            int64_t idx = stk.back()[0];
            if (idx >= seg[0] && eval(stk.back(), idx) <= eval(seg, idx)) {
                stk.pop_back();
            } else {
                break;
            }
        }

        if (!stk.empty() && endIndex(stk.back()) > seg[0] && eval(stk.back(), seg[0]) > eval(seg, seg[0])) {
            int64_t lo = seg[0];
            int64_t hi = std::min(endIndex(stk.back()), endIndex(seg));
            while (lo + 1 < hi) {
                int64_t mid = std::midpoint(lo, hi);
                if (eval(stk.back(), mid) > eval(seg, mid)) {
                    lo = mid;
                } else {
                    hi = mid;
                }
            }

            seg[1] = hi - seg[0];
            seg[0] = hi;
        }

        stk.push_back(seg);
    }

    std::vector<int64_t> ans = a;
    auto it = stk.begin();
    for (auto i = 1; i < ans.size(); ++i) {
        while (std::next(it) != stk.end() && (*std::next(it))[0] <= i)
            ++it;

        ans[i] = std::max(ans[i], eval(*it, i));
    }

    return ans;
}

void add(State& state, std::vector<int64_t>& v) {
    std::ranges::sort(v, std::greater<>());
    for (size_t i = 1; i < v.size(); ++i) {
        v[i] += v[i - 1];
    }

    int32_t m = state.size();
    for (int32_t i = 0; i < m; ++i) {
        state[i] = merge(state[i], v);
    }

    v.clear();
}

void multiply(State& state, int64_t v) {
    state.push_back(state.back());
    int32_t m = state.size();
    int32_t n = state[0].size();
    for (int32_t i = m - 2; i >= 0; --i) {
        for (int32_t j = 0; j < n; ++j) {
            state[i + 1][j] = std::max(state[i + 1][j], state[i][j] * v);
        }
    }
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int32_t n, maxK;
    std::cin >> n >> maxK;

    State ans(1, std::vector<int64_t>(n + 1, 0));

    std::vector<int64_t> buffer;
    for (int32_t i = 0; i < n; ++i) {
        char op;
        int64_t v;
        std::cin >> op >> v;
        if (op == 'a') {
            buffer.push_back(v);
        } else {
            if (!buffer.empty()) {
                add(ans, buffer);
            }

            multiply(ans, v);
        }
    }

    if (!buffer.empty()) {
        add(ans, buffer);
    }

    std::vector<int64_t> result(n + ans.size() + 1, 0);
    for (size_t i = 0; i < std::min<size_t>(maxK + 1, ans.size()); ++i) {
        for (int32_t j = 0; j <= n; ++j) {
            result[i + j] = std::max(result[i + j], ans[i][j]);
        }
    }

    for (int32_t x = 1; x <= n; ++x) {
        result[x] = std::max(result[x], result[x - 1]);
        std::cout << result[x] << '\n';
    }

    return 0;
}