#include <bits/stdc++.h>
using namespace std;
long long int bigprime = 999999733;
string dc(int arrA, int arrB) {
  cout << " (" << arrA << "," << arrB << ") -> ";
  string s = "";
  return s;
}
string dc(long long int arrA, long long int arrB) {
  cout << " (" << arrA << "," << arrB << ") -> ";
  string s = "";
  return s;
}
void yes() { cout << "YES" << endl; }
void no() { cout << "NO" << endl; }
void Alice() { cout << "Alice" << endl; }
void Bob() { cout << "Bob" << endl; }
int fillSegTree(int cur, int l, int r, vector<int> &segtree, vector<int> &arr) {
  int n = arr.size();
  if (l == r && l < n) {
    segtree[cur] = arr[l];
    return segtree[cur];
  }
  if (l == r && l >= n) {
    segtree[cur] = INT_MAX;
    return segtree[cur];
  }
  int left, right;
  left = fillSegTree(2 * cur + 1, l, (l + r) / 2, segtree, arr);
  right = fillSegTree(2 * cur + 2, (l + r) / 2 + 1, r, segtree, arr);
  segtree[cur] = min(left, right);
  return segtree[cur];
}
int bataSegTree(int cur, int ql, int qr, int l, int r, vector<int> &segtree) {
  if (ql <= l && r <= qr) {
    return segtree[cur];
  } else if (r < ql || qr < l) {
    return INT_MAX;
  } else {
    int left, right, mid;
    mid = (l + r) / 2;
    left = bataSegTree(2 * cur + 1, ql, qr, l, mid, segtree);
    right = bataSegTree(2 * cur + 2, ql, qr, mid + 1, r, segtree);
    return min(left, right);
  }
}
void update_SegTree(int cur, vector<int> &segtree) {
  if (cur < 0) return;
  int left = segtree[2 * cur + 1];
  int right = segtree[2 * cur + 2];
  segtree[cur] = min(left, right);
  int PAPA = (cur - 1) / 2;
  if (PAPA != 0) update_SegTree(PAPA, segtree);
}
bool inGrid(int i, int j, int n, int m) {
  if (i < 0 || j < 0 || i >= n || j >= m) return false;
  return true;
}
int digsum(long long num) {
  int sum = 0;
  while (num > 0) {
    sum += num % 10;
    num /= 10;
  }
  return sum;
}
void topo_dfs(int cur, stack<int> &st, unordered_map<int, vector<int>> &mp,
              unordered_set<int> &vis) {
  vis.insert(cur);
  for (int i = 0; i < mp[cur].size(); i++) {
    int nex = mp[cur][i];
    if (!vis.count(nex)) topo_dfs(nex, st, mp, vis);
  }
  st.push(cur);
}
vector<int> topoSort(unordered_map<int, vector<int>> &mp) {
  stack<int> s;
  unordered_set<int> vis;
  for (auto it = mp.begin(); it != mp.end(); it++) {
    int cur = it->first;
    if (!vis.count(cur)) topo_dfs(cur, s, mp, vis);
  }
  vector<int> ans;
  while (!s.empty()) {
    ans.push_back(s.top());
    s.pop();
  }
  return ans;
}
bool CYCLE_dfs(int s, unordered_map<int, vector<int>> &adj,
               unordered_set<int> &gray, unordered_set<int> &black) {
  if (gray.count(s)) return true;
  if (black.count(s)) return false;
  gray.insert(s);
  for (int i = 0; i < adj[s].size(); i++) {
    int nex = adj[s][i];
    if (CYCLE_dfs(nex, adj, gray, black)) return true;
  }
  gray.erase(s);
  black.insert(s);
  return false;
}
bool isCyclic(unordered_map<int, vector<int>> &adj) {
  unordered_set<int> gray;
  unordered_set<int> black;
  vector<int> white;
  for (auto it = adj.begin(); it != adj.end(); it++) {
    int w = it->first;
    white.push_back(w);
  }
  for (int p = 0; p < white.size(); p++) {
    int i = white[p];
    if (!gray.count(i) && !black.count(i)) {
      if (CYCLE_dfs(i, adj, gray, black)) return true;
    }
  }
  return false;
}
bool compstd(pair<int, int> l, pair<int, int> r) { return l.first > r.first; }
int main() {
  std::ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  int n, c;
  cin >> n >> c;
  vector<long long int> arrA(n, 0), arrB(n, 0);
  for (int i = 0; i < n - 1; i++) cin >> arrA[i];
  for (int i = 0; i < n - 1; i++) cin >> arrB[i];
  int dp[2][n];
  memset(dp, 0, sizeof(dp));
  dp[0][0] = arrA[0];
  dp[1][0] = arrB[0] + c;
  cout << 0 << " ";
  for (int i = 1; i < n; i++) {
    int a = dp[0][i - 1], b = dp[1][i - 1];
    if (a < b) {
      cout << a << " ";
      dp[0][i] = a + arrA[i];
      dp[1][i] = min(b + arrB[i], a + c + arrB[i]);
    } else {
      cout << b << " ";
      dp[0][i] = b + arrA[i];
      dp[1][i] = b + arrB[i];
    }
  }
  return 0;
}
