// 1.dfs顺序 : 枚举预期的原木棍长，验证是否能拼接成； 选该碎木棍拼接或不选

// 2.dfs状态 : 
// 2.1 状态：预期长度，预期个数，当前拼接的木棍序号，当前拼接木棍长度，碎木棍使用情况
// 2.2 层次：当前用x碎木棍拼接 当前的y原木棍
// 2.3 分支：~

// 3.剪枝： 
// 3.1 优化搜索顺序： 排序后先按大的挑
// 3.2 排除等效冗余：
// 3.2.1 顺序等效：if x > y 那么先用x和先用y都是等效的，所以只按从大到小顺序拼接
// 3.2.2 长度等效：如果一次拼接使用的长度失败，使用其他等长木棍也会失败
// 3.2.3 原木棍等效： 如果存在任意一个木棍无法拼接，那么方案必定不合法
// 3.2.4 没懂？
// 3.3 可行性剪枝（确定上下界）：枚举的范围，
// 3.4 最优性剪枝：？
// 3.5 记忆化：无



import java.util.*;
import java.util.stream.*;
public class Main{

    void run(){
        while(true){
            int n = jin.nextInt();
            if (n == 0) break;
            slice.clear();
            for (int i = 0 ; i < n ;i ++) {
                int x = jin.nextInt();
                if (x <= 50) slice.add(x);
            }
            n = slice.size();
            System.out.println(solve(n));
        }
    }

    int solve(int n){
        int maxLen = 0;
        int sumLen = 0;

        slice.sort((a,b)->(b-a));

        for (int i = 0 ; i< slice.size() ; i++){
            maxLen = Math.max(maxLen, slice.get(i));
            sumLen += slice.get(i);
        }

        for (int i = maxLen; i <= sumLen ; i++){
            if (sumLen % i != 0) continue; // 开始落下了。。。
            Arrays.fill(visit, false);  // 忘记恢复状态了， 因为剪枝的原因可能没全自动恢复0
            if (dfs(i, 0, 0, 0, slice.size(), sumLen/i)) return i;
        }

        return 0;
    }

    boolean dfs(int len, int cur, int cab, int last, int n, int nums){
        if (cur == nums) return true;
        if (cab == len) return dfs(len, cur + 1, 0, 0, n, nums);

        for (int i = last ; i < n ; i++){
            if (visit[i]) continue;
            int l =  slice.get(i);
            if (cab + l> len) continue;

            visit[i] = true;
            if (dfs(len, cur, cab + l, i+1, n, nums)) return true;
            visit[i] = false;

            if (cab == 0 || cab + l == len) return false; // 剪枝开头末尾
            while (i+1 < n && slice.get(i+1) == l) i++; // 剪枝相等的

        }

        return false;
    }


    boolean wrongDfs(int len, int cur, int n, int nums){

        if (cur == nums) return true;
        System.out.printf("p:%s\n", prime[cur]);
        for (int i = 0 ; i < n ; i++){
            if (visit[i]) continue;
            if (prime[cur] + slice.get(i) > len) continue;
            System.out.printf("s:%s\n", slice.get(i));
            prime[cur] += slice.get(i); // 这样失败无法恢复状态
            visit[i] = true;            // 就是书上说的没分清 “层次” 和 “分支”
        }
        System.out.printf("p:%s\n", prime[cur]);
        for (int i = 0 ; i < n ; i ++){
            if (visit[i]) continue;
            System.out.printf("%d ", slice.get(i));
        }
        System.out.println();
        if (prime[cur] == len) return wrongDfs(len, cur + 1, n, nums);

        return false;

    }

    private int maxNum = 3202;
    private boolean[] visit = new boolean[maxNum];
    private List<Integer> slice = new ArrayList<>();
    private int[] prime = new int[maxNum];

    private Scanner jin = new Scanner(System.in);
    public static void main(String[] args) throws Exception {new Main().run();}
}