package main

import (
	"fmt"
	"math/big"
)

func main() {
	var n int
	if _, err := fmt.Scan(&n); err != nil {
		return
	}

	a := make([]int, n)
	counts := make(map[int]int)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i])
		counts[a[i]]++
	}

	if len(counts) <= 1 {
		fmt.Println(n)
		return
	}

	dp := make([][]*big.Int, n+1)
	for i := range dp {
		dp[i] = make([]*big.Int, 10001)
		for j := range dp[i] {
			dp[i][j] = new(big.Int)
		}
	}
	dp[0][0].SetInt64(1)

	currentSum := 0
	currentCnt := 0
	for _, w := range a {
		currentCnt++
		currentSum += w
		for i := currentCnt; i >= 1; i-- {
			for j := currentSum; j >= w; j-- {
				if dp[i-1][j-w].Sign() > 0 {
					dp[i][j].Add(dp[i][j], dp[i-1][j-w])
				}
			}
		}
	}

	maxRevealed := 0
	for x, c := range counts {
		for k := 1; k <= c; k++ {
			req := k * x
			ncr := big.NewInt(1)
			for i := 1; i <= k; i++ {
				ncr.Mul(ncr, big.NewInt(int64(c-i+1)))
				ncr.Div(ncr, big.NewInt(int64(i)))
			}

			if dp[k][req].Cmp(ncr) == 0 {
				revealed := k
				if k == c && len(counts) == 2 {
					revealed = n
				}
				if revealed > maxRevealed {
					maxRevealed = revealed
				}
			}
		}
	}

	fmt.Println(maxRevealed)
}