// Slower C++ solution:
#include <iostream>

#include <cstdio>

using namespace std;

#define rep(i,n) for(int i=0;i<(n);i++)



int main(){

	int weight;

	int n,v,w,c=0;

	int dp[1001][1001];

	while(scanf("%d\n",&weight) && weight){

		c++;

		rep(i,1001)rep(j,1001)dp[i][j]=0;

		

		scanf("%d\n",&n);

		for(int k=1;k<=n;k++){

			scanf("%d,%d\n",&v,&w);

			for(int i=0;i<=w;i++){

				dp[k][i] = dp[k-1][i];

			}

			for(int i=w;i<=weight;i++){

				dp[k][i] = max(dp[k-1][i],dp[k-1][i-w]+v);

			}

		}

		/*for(int k=0;k<=n;k++){

			for(int i=0;i<=weight;i++)

				printf("%4d",dp[k][i]);

			puts("");

		}*/

		printf("Case %d:\n",c);

		printf("%d\n",dp[n][weight]);

		for(int i=0;i<=weight;i++){

			if(dp[n][i]==dp[n][weight]){

				printf("%d\n",i);

				break;

			}

		}

	}

}

// Faster C++ solution for the same problem (measured speedup: 7.0211809342539695x):
#include <bits/stdc++.h>

using namespace std;



struct Item{

	int v,w;

	int idx;	

};

const int INF = 1000000000;

class Knapsack{

public:

	

	

	int maximumWeight;

	vector<Item> items;

	Knapsack(int maximumWeight_,vector<Item> items_) : maximumWeight(maximumWeight_),items(items_) {

		used.resize(items.size(),false);

		totalWeight = totalValue = 0;

		sort(items.begin(),items.end(),[](Item a,Item b){ return a.v * b.w > b.v * a.w; });

	}

	int totalValue;

	int totalWeight;

	vector<bool> used;

	bool operator < (const Knapsack &op) const {

		if( totalValue == op.totalValue )

			return totalWeight > op.totalWeight;

		return totalValue < op.totalValue;

	}



	bool canPut(const Item &x){

		return !used[x.idx] && x.w <= maximumWeight - totalWeight;

	}

	bool putItem(const Item &x){

		if( canPut(x) ){

			totalWeight += x.w;

			totalValue += x.v;

			used[x.idx] = true;

			return true; // success

		}else{

			return false; // failure

		}

	}

	bool removeItem(const Item &x){

		if( used[x.idx] ){

			totalWeight -= x.w;

			totalValue -= x.v;

			used[x.idx] = false;

			return true;

		}

		return false;

	}

	int swapAtoB(Item x,Item y){

		if( used[x.idx] && !used[y.idx] ){

			if( totalWeight - x.w + y.w > maximumWeight ) return -INF;

			return y.v - x.v;

		}else{

			return -INF;

		}

	}

	Knapsack knapSackDP(int scale) const{

		Knapsack res = *this;

		int maximumValue = -INF;

		for( auto i : res.items ){

			maximumValue = max(maximumValue,i.v);

		}



		double rate = min(1.0,1.*scale/maximumValue);

		for( auto &i : res.items ){

			i.v = (int)(ceil(rate*i.v)+1e-9);

		}

		

		vector<int> dp(scale+1,INF),lastId(scale+1,-1);

		dp[0] = 0;

		for(int i = 0 ; i < res.items.size() ; i++){

			if( res.used[i] ) continue;

			for(int j = scale ; j >= res.items[i].v ; j--){

				if( dp[j-res.items[i].v] + res.items[i].w < dp[j] ){

					dp[j] = dp[j-res.items[i].v] + res.items[i].w;

					lastId[j] = i;

				}

			}

		}

		for(int i = scale ; i >= 0 ; i--){

			if( dp[i] <= maximumWeight - totalWeight ){

				int cur = i;

				while(cur > 0){

					int p = lastId[cur];

					res.putItem(res.items[p]);

					cur -= res.items[p].v;

					if( p == -1 ) exit(0);

				}

				break;

			}

		}

		return res;

	}

	Knapsack localImprovement() const{

		Knapsack res = *this;

		while(true){

			// ????¬??????????????????????????????§??????????

			for(int i = 0 ; i < res.items.size() ; i++){	

				res.putItem(res.items[i]);

			}

			auto reflesh = [&](){

				for(int i = 0 ; i < res.items.size() ; i++){

					if( res.used[i] ){



						auto tmp = res;

						tmp.removeItem(tmp.items[i]);

						for(int j = 0 ; j < tmp.items.size() ; j++){

							if( i != j && !tmp.used[j] ){	

								tmp.putItem(tmp.items[j]);

							}

						}

						if( res < tmp ){

							res = tmp;

							return true;

						}

					}

				}

				return false;

			};

			if( reflesh() ) continue;

			

			auto reflesh2 = [&](){

				for(int i = 0 ; i < res.items.size() ; i++){

					if( res.used[i] ){



						for(int j = 0 ; j < res.items.size() ; j++){

							if( !res.used[j] ){

								if( res.swapAtoB(res.items[i],res.items[j]) >= 0 ){

									res.removeItem(res.items[i]);

									res.putItem(res.items[j]);

									return true;

								}

							}

						}

					}

				}

				return false;

			};

			if( reflesh2() ) continue;

			break;

		}

		return res;

	}

};









int main(){

	int n,m;

	int t=1;

	while(cin >> n >> m && n){

		vector<Item> items;

		for(int i = 0 ; i < m ; i++){

			int x,y;

			scanf("%d,%d",&x,&y);

			items.push_back({x,y,i});

		}

		Knapsack knap(n,items);

		knap = knap.knapSackDP(12000);

		cout << "Case " << t++ << ":" << endl;

		//knap = knap.localImprovement();

		cout << knap.totalValue << "\n" << knap.totalWeight << endl;

	}

}