Problem: You are hired by the ∀I¶אΞ℘, an extraterrestrial intelligence, as a programmer of their typesetting system. Your task today is to design an algorithm for text justification.

Text justification is to equalize the line widths as much as possible by inserting line breaks at appropriate posi- tions, given a word sequence called a paragraph and the width of the paper. Since you have not developed an automatic hyphenation algorithm yet, you cannot break a line in the middle of a word. And since their language does not put spaces between words, you do not need to consider about spacing.

To measure how well the text is justified in one configuration (i.e., a set of lines generated by inserting line breaks to a paragraph), you have defined its cost as follows:

* The total cost of a paragraph is the sum of the cost of each line.
* The cost for the last line is defined as max(0, s - w).
* The cost for other lines are given by |s - w|.



where s is the sum of the widths of the words in the line, and w is the width of the paper.

Please design the algorithm which takes a paragraph and calculates the configuration of the minimum cost.



Input

The input consists of multiple test cases.

The first line of each test case contains two positive integers n and w (0 ≤ n ≤ 1000 and 0 ≤ w ≤ 1,000,000). n is the length of paragraph and w is the width of the used paper. Each of the following n lines contains one positive integer ai which indicates the width of the i-th word in the paragraph. Here it is guaranteed that 0 ≤ ai ≤ w.

The input terminates with the line containing two zeros. This is not a part of any test case and should not be processed.

Output

For each test case, print the case number and the minimum cost for the paragraph.

Example

Input

4 10
8
6
9
1
4 7
1
2
3
4
0 0


Output

Case 1: 4
Case 2: 1

Solution (in CPP):

Solution:
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <string>
#include <set>
#include <cmath>
using namespace std;

struct Edge;
typedef vector<vector<Edge> > G;

const int INF = (1<<28);

struct Edge {
  int to, cost;
};

struct State {
  int v, cost;
  bool operator < (const State &s) const {
    return cost > s.cost;
  }
};

void addEdge(int a, int b, int c, G *_g) {
  G &g = *_g;
  if(g.size() < max(a,b)+1) g.resize(max(a,b)+1);
  g[a].push_back((Edge){b, c});
  g[b].push_back((Edge){a, c});
}

vector<int> dijkstra(const G &g, int v) {
  vector<int> res(g.size(), INF);
  priority_queue<State> que;
  State s = {v, 0};
  res[v] = 0;
  que.push(s);
  while(!que.empty()) {
    s = que.top();
    que.pop();
    if(s.cost > res[s.v]) continue;
    for(int i = 0; i < g[s.v].size(); ++i) {
      const Edge &e = g[s.v][i];
      int ncost = s.cost + e.cost;
      if(ncost >= res[e.to]) continue;
      res[e.to] = ncost;
      que.push((State){e.to, ncost});
    }
  }
  return res;
}


int main() {
  int n, w;
  while(cin >> n >> w && (n|w)) {
    vector<int> a(n);
    for(int i = 0; i < n; ++i) {
      cin >> a[i];
    }
    vector<int> S(n+1);
    S[0] = 0;
    for(int i = 0; i < n; ++i) {
      S[i+1] = S[i] + a[i];
    }

    G g;
    for(int i = 0; i < n; ++i) {
      for(int j = i+1; j <= n; ++j) {
        int cost;
        int s = S[j] - S[i];
        if(j == n) {
          cost = max(0, s - w);
        } else {
          cost = abs(s - w);
        }
        addEdge(i, j, cost, &g);
      } 
    }

    int V = g.size();
    vector<int> v = dijkstra(g, 0);
    static int tc = 0;
    cout << "Case " << ++tc << ": " << v[n] << endl;

  }
  return 0;
}