Go: package main

import "fmt"

func main() {
	var v float64
	for {
		i, _ := fmt.Scan(&v)
		if i == 0 {
			break
		}
		t := v / 9.8
		y := 4.9 * t * t

		N := 0
		for {
			N++
			if height := 5*N - 5; float64(height) > y {
				fmt.Println(N)
				break
			}
		}
	}
}

C++: #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif

#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif

#include <array>

using namespace std;

int main ()
{
	double x;
	while( cin >> x )
	{
		cout << (int)( pow ( x / 9.8 , 2 )*4.9 + 9.99999999 ) / 5 << endl;
	}
}

C++: #include <iostream>
#include <cstdio>
#include <math.h>

using namespace std;

int main(void){
    double v;
    
    while (cin>>v)
    {
        double n,k;
        n = (4.9*(v/9.8)*(v/9.8)+5)/5;
        //cout<<"n="<<n<<endl;
        k=n-(int)n;
        if(0.5<=k){n+=1-k;}
        else {n-=k;}
        cout<<n<<endl;
    }
    return 0;
}

C++: #include <cmath>
#include <cstdio>
#include <iostream>

using namespace std;

int main() {
	float v;
	while (scanf("%f", &v) != EOF) {
		printf ("%d\n", (int)ceil((v * v / 19.6 + 5) / 5.0 + 0.000000001));
	}
	return 0;
}

C++: #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES

#include "bits/stdc++.h"
#define REP(i,a,b) for(int i=a;i<b;++i)
#define rep(i,n) REP(i,0,n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define ALL(a) begin(a),end(a)
#define ifnot(a) if(not (a))
#define dump(x)  cerr << #x << " = " << (x) << endl
using namespace std;

// #define int ll
#ifdef _MSC_VER
const bool test = true;
#else 
const bool test = false;
#endif

int dx[] = { 0,1,0,-1 };
int dy[] = { 1,0,-1,0 };
#define INF (1 << 28)
ull mod = (int)1e9 + 7;
//.....................
const int MAX = (int)2e5 + 5;

double v;

int main() {
	while (cin >> v) {
		double t = v / 9.8;
		double y = 4.9*t*t;
		int floor = ceil( y / 5 + 1 + 1e-8);
		cout << floor << endl;
	}
	return 0;
}

C++: #include<iostream>
using namespace std;
int main() {
	float v,y,t;
	while (cin >> v) {
		t = v / 9.8;
		y = 4.9*t*t;
		int a=-5;
		int ans = 0;
		while (1) {
			ans = ans + 1;
			a = a + 5;
			if (y <= a) {
				goto a;
			}
		}
	a:;
		cout << ans << endl;
	}
}

C++: ////   template  ///////////////////////////////////////////////////////
#include <stdlib.h>
#include <sys/time.h>
#include <stdio.h>
#include <sys/resource.h>
#include <iostream>
using namespace std;

class timer{
	enum KIND{ REAL, CPU }; // real_time or cpu_time
	double t0; // start
	double t1; // end
	KIND kind_of_time; // default is real_time
	double get_realtime(){struct timeval tv; gettimeofday(&tv, NULL);
		return tv.tv_sec + (double)tv.tv_usec*1e-6;}
	double get_cputime(){struct rusage RU; getrusage(RUSAGE_SELF, &RU); 
		return RU.ru_utime.tv_sec + (double)RU.ru_utime.tv_usec*1e-6;}
public:
	timer(){kind_of_time = REAL;}
	void set(KIND k){kind_of_time = k;}
	void start(){t0 = get_realtime();}
	void stop(){t1 = get_realtime();}
	void print(){printf("TotalTime : %.3fsec\n", t1-t0);}
};
////////////////////////////////////////////////////////////////////////

/*
  v = 9.8t
  y = 4.9t*t
*/

int main()
{
	double v;
	while(cin>>v)
	{
		double y = v*v/19.6;
		int n = (int)(y/5.0) + 2 ;
		cout << n << endl;
	}

    return 0;
}

C++: #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for(int i=0; i<(n); ++i)
#define FOR(i, m, n) for(int i=(m); i<(n); ++i)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define mp make_pair
#define pb push_back
#define Cout(x) cout << (x) << endl
#define dump(x) cerr << #x << " = " << (x) << endl;
typedef long long LL;
typedef vector<int> VI;
typedef vector<long long> VL;
typedef vector<string> VS;
typedef vector<vector<int>> VVI;
typedef pair<int, int> PII;
const int inf = (int)1e9;
const long long mod = 998244353LL;
const double pi = acos(-1.0);

double gosa = 0.00000001;

int main() {
	double a;
	while (cin >> a) {

		int ans = 0;
		for (int i = 0; true; i += 5) {
			double v = 9.8 * sqrt((double)i / 4.9);
			if (a-v < gosa) { ans = i; break; }
		}
		Cout((ans + 5) / 5);
	}
}

C++: #include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <cctype>
#include <iostream>
#include <set>
#include <string>
#include <queue>
#include <map>
using namespace std;
int size(string x){
	string::size_type size=x.size();
	return size;
}
#define fu(l,k) for(int i=l;i<k;i++)
#define fd(l,k) for(int i=l;i>k;i--)
#define fi first
#define se second
typedef  vector<string> vs;
typedef  vector<int> vi;
double pi(){
	return M_PI;
}
typedef set<int> set_i;
typedef set<string> set_s;
int main(){
	double n,x,t,h;
	while(cin>>x){
		t=x/9.8;
		h=4.9*t*t;
		n=h/5;
		if(h%5==0) cout<<n-1<<endl;
		else cout<<n<<endl;
	}
}

C++: #include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;

int main(){
	float input;
	while(scanf("%f", &input) != EOF){
		int ans = 1;
		while(1){
			float time = sqrt((5*ans - 5) / 4.9);
			float speed = time * 9.8;
			if(input < speed) break;
			ans++;
		}
		cout << ans << endl;
	}
}

C++: #include<iostream>
#include<cmath>
using namespace std;

int main(){
	double mv;
	while (cin >> mv)
		cout << ceil((mv*mv / (9.8f * 2)) / 5 + 1) << endl;
}

C++: #include <iostream>
#include <cstdio>
using namespace std;

int main(void) {
	float v, y, t, n, ans;

  while (cin >> v) {
    t = v / 9.8;
    y = 4.9 * t * t;
    n = (y + 5) / 5;
    ans = (int)n;
    
    if (n - ans > 0.5) ans++;
    cout << ans << endl;
	}
}

C++: #include <iostream>
using namespace std;

int main()
{
	double x;
	
	while(scanf("%lf", &x) != EOF){
		x = x / 9.8;
		x = x * x * 4.9;
		int i;
		for(i = 1; i * 5 - 5 < x; i++);
		cout << i << endl;
	}
	return 0;
}

C++: #include<cstdio>
#include<algorithm>
#include<vector>
#include<string>
#include<iostream>
#include<queue>
#include<map>
#include<set>
#include<complex>
#include<stack>
#include<cmath>

using namespace std;

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


#define X real()
#define Y imag()
typedef complex<double> P;

int main(){
	  
	  double a;
	  while(cin>>a){
	  	double t = a/9.8;
		for(int i=0;;i++){
			double h = 5*i-5;
			if(h>=4.9*t*t){
				printf("%d\n",i);
				break;
			}
		}
	  }
	
}

C++: #include <iostream>
#include <cmath>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    double v;
    while(cin>>v) {
        double y=v*v/19.6;
        cout<<(int)ceil(y/5+1)<<'\n';
    }
    return 0;
}