The cow bicycling team consists of N (1 <= N <= 20) cyclists. They wish to determine a race strategy which will get one of them across the finish line as fast as possible.

Like everyone else, cows race bicycles in packs because that's the most efficient way to beat the wind. While travelling at x laps/minute (x is always an integer), the head of the pack expends x*x energy/minute while the rest of pack drafts behind him using only x energy/minute. Switching leaders requires no time though can only happen after an integer number of minutes. Of course, cows can drop out of the race at any time.

The cows have entered a race D (1 <= D <= 100) laps long. Each cow has the same initial energy, E (1 <= E <= 100).

What is the fastest possible finishing time? Only one cow has to cross the line. The finish time is an integer. Overshooting the line during some minute is no different than barely reaching it at the beginning of the next minute (though the cow must have the energy left to cycle the entire minute). N, D, and E are integers.

A single line with three integers: N, E, and D 

A single line with the integer that is the fastest possible finishing time for the fastest possible cow. Output 0 if the cows are not strong enough to finish the race. 

3 30 20

7

[as shown in this chart:


	                            leader E


	               pack  total used this


	time  leader  speed   dist   minute


	  1      1      5       5      25


	  2      1      2       7       4


	  3      2*     4      11      16


	  4      2      2      13       4


	  5      3*     3      16       9


	  6      3      2      18       4


	  7      3      2      20       4


	* = leader switch

for(int d = 1; d <= D; d++) {

    for(int e = 1; e <= E; e++) {

    	for(int k = 1; k*k <= e && k <= d; k ++) {//完全背包

    		dp[d][e] = min(dp[d][e], dp[d-k][e-k*k]+1)

    	}

    }

}

dp[i+1][d][d] = min(dp[i+1][d][d], dp[i][d][e]);

#include <iostream>

using namespace std;

const int INF = 0X3F3F3F3F;

const int MAXN = 30;

int N, E, D;

int dp[30][110][110];

int main() {

	freopen("E:\\Copy\\ACM\\poj\\1661\\in.txt", "r", stdin);

	while(cin >> N >> E >> D) {

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

			for(int j = 0; j <= D; j ++)

				for(int k = 0; k <= E; k++)

					dp[i][j][k] = INF;

		dp[1][0][0] = 0;

		for(int i = 1; i <= N; i ++) {

			for(int j = 1; j <= D; j++) {

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

					for(int s = 1; s*s <= k && s <= j; s ++) {

						dp[i][j][k] = min(dp[i][j][k], dp[i][j-s][k-s*s]+1);

					}

					dp[i+1][j][j] = min(dp[i+1][j][j], dp[i][j][k]); // 第 i+1 头牛继承第 i 头牛的成果

				}

			}

		}

		int ans = INF;

		for(int k = 1; k <= E; k ++)

			ans = min(ans, dp[N][D][k]);

		cout << ans << endl;

	}

	return 0;

}