uva1377

#include <iostream>
#include <istream>
#include <sstream>
#include <vector>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <cstring>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <numeric>
#include <chrono>
#include <ctime>
#include <cmath>
#include <cctype>
#include <string>
#include <cstdio>
#include <iomanip>


#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <iterator>
using namespace std;

const int maxn = 64,maxm = 2100000;
int n,m,input[maxn],mx,vis[maxm];
unordered_map<int, int> mmp;
vector<int> ans;

struct Node {
    
	int state;
	set<int> st;
	bool isOver(int val) {
    
		return state == val;
	}
	bool HasFlag(int index) {
    
		return state & (1 << index);
	}
	vector<int> GetResult() {
    
		vector<int> ret;
		for (auto it = st.begin(); it != st.end(); it++) {
    
			ret.push_back(*it);
		}
		return ret;
	}
	void AddVal(int input) {
    
		int dis = 0;
		for (auto it = st.begin(); it != st.end(); it++) {
    
			dis = abs(*it - input);
			if (!mmp.count(dis)) continue;
			state |= (1 << mmp[dis]);
		}
		st.insert(input);
	}
};


void bfs() {
    
	queue<Node> q;
	Node head;
	head.state = 0;
	head.st.insert(0);

	q.push(head);

	int over = (1 << n) - 1;
	while (!q.empty()) {
    
		head = q.front(); q.pop();

		if (head.isOver(over)) {
    
			ans = head.GetResult();
			return;
		}
		if (head.st.size() >= 7) continue;

		for (int i = 0; i < n; i++) {
    
			if (!head.HasFlag(i)) {
    
				for (auto it = head.st.begin(); it != head.st.end(); it++) {
    
					if (*it + input[i] <= mx) {
    
						int nx = *it + input[i];
						Node tmp = head;
						tmp.AddVal(nx);
						if (vis[tmp.state])continue;
						vis[tmp.state] = 1;
						q.push(tmp);
					}
				}
			}
		}

		for (int i = 0; i < n; i++) {
    
			if (!head.HasFlag(i)) {
    
				for (auto it = head.st.begin(); it != head.st.end(); it++) {
    
					if (*it - input[i] > 0) {
    
						int nx = *it - input[i];
						Node tmp = head;
						tmp.AddVal(nx);
						if (vis[tmp.state])continue;
						vis[tmp.state] = 1;
						q.push(tmp);
					}
				}
			}
		}
	}
}

int main() {
    
	int kCase = 1;
	while (cin >> n && n) {
    
		mmp.clear();
		for (int i = 0; i < n; i++) cin >> input[i];
		sort(input, input + n);
		n = unique(input, input + n) - input;
		memset(vis, false, sizeof(vis));
		mx = input[n - 1];
		for (int i = 0; i < n; i++) mmp[input[i]] = i;
		ans.clear();
		bfs();
		int sz = ans.size();
		cout << "Case " << kCase++ << ":" << endl << sz << endl;
		for (int i = 0; i < sz; i++) {
    
			if (i)cout << " " << ans[i];
			else cout << ans[i];
		}
		cout << endl;
	}
	return 0;
}