#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>

using namespace std;

void gen(vector<pair<int, vector<int64_t>>>& v, const vector<int64_t>& dp) {
  vector<int64_t> diffs;
  for(int i = 1; i < dp.size(); i++) diffs.push_back(dp[i] - dp[i-1]);
  int64_t p = 1e18;
  int lhs = 0;
  vector<int64_t> curr;
  for(int i = 0; i < diffs.size(); i++) {
    if(diffs[i] > p) {
      v.emplace_back(lhs, curr);
      lhs += curr.size();
      curr.clear();
      curr.push_back(dp[i+1]);
      p = dp[i+1];
    }
    else {
      // normal case
      curr.push_back(diffs[i]);
      p = diffs[i];
    }
  }
  v.emplace_back(lhs, curr);
}

void upd(vector<int64_t>& dp, int base, const vector<int64_t>& a, const vector<int64_t>& b) {
  int ai = 0;
  int bi = 0;
  int64_t curr = 0;
  for(int i = base+1; ai < a.size() || bi < b.size(); i++) {
    if(ai == a.size() || (bi < b.size() && b[bi] > a[ai])) {
      curr += b[bi++];
    }
    else {
      curr += a[ai++];
    }
    dp[i] = max(dp[i], curr);
  }
}

void dump(const vector<int64_t>& v) {
  for(auto out: v) cerr << out << " ";
}
void combine(vector<int64_t>& dp, const vector<int64_t>& adp, const vector<int64_t>& bdp) {
  //cerr << "combining ";
  //dump(adp);
  //cerr << " with ";
  //dump(bdp); cerr << endl;
  vector<pair<int, vector<int64_t>>> a, b;
  gen(a, adp);
  gen(b, bdp);
  dp.resize(adp.size() + bdp.size() - 1);
  for(auto& aa: a) for(auto& bb: b) upd(dp, aa.first + bb.first, aa.second, bb.second);
  //dump(dp); cerr << endl << endl;
}

int main() {
  int n, mxk;
  cin >> n >> mxk;
  vector<int> vals(n);
  for(int i = 0; i < n; i++) {
    char c;
    cin >> c >> vals[i];
    if(c == 'm') vals[i] *= -1;
  }
  vector<vector<int64_t>> dp;
  vector<int64_t> ret(n+1);
  auto mul = [&](int scale) {
    int idx = -1 + (int)dp.size();
    while(idx >= 0) {
      if(idx + 1 == dp.size()) dp.push_back(vector<int64_t>(dp[idx].size()));
      if(dp[idx+1].size() < dp[idx].size()) dp[idx+1].resize(dp[idx].size());
      for(int a = 0; a < dp[idx].size(); a++) {
        dp[idx+1][a] = max(dp[idx+1][a], dp[idx][a] * scale);
      }
      idx--;
    }
  };
  for(int i = 0; i < n;) {
    if(vals[i] < 0) mul(-vals[i++]);
    else {
      int j = i+1;
      while(j < n && vals[j] >= 0) j++;
      vector<int64_t> cands(j-i);
      for(int k = i; k < j; k++) cands[k-i] = vals[k];
      sort(cands.rbegin(), cands.rend());
      vector<int64_t> psum;
      psum.push_back(0);
      for(auto out: cands) psum.push_back(psum.back() + out);
      if(dp.size() == 0) {
        dp.push_back(psum);
      }
      else {
        for(int a = 0; a < dp.size(); a++) {
          vector<int64_t> ndp;
          combine(ndp, dp[a], psum);
          dp[a].swap(ndp);
        }
      }
      i = j;
    }
  }
  for(int i = 0; i < min(mxk+1, (int)dp.size()); i++) for(int j = 0; j < dp[i].size(); j++) ret[i+j] = max(ret[i+j], dp[i][j]);
  for(int i = 1; i <= n; i++) {
    ret[i] = max(ret[i], ret[i-1]);
    cout << ret[i] << "\n";
  }
}