#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include<iomanip>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define clr(a) memset(a, 0, sizeof(a))
#define sz(x) x.size()
#define rep(n) for (ll i = 0; i < n; i++)
#define repc(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, x, y) for (int i = x; i < y; i++)
#define DEC(i, x, y) for (int i = x; i >= y; i--)
#define all(v) v.begin(), v.end()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define alla(a, n) a, a + n

using namespace std;

// Some typedef's
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;

// UTILITY FUNCTIONS

// String
char toUpper(const char &c) { return isupper(c) ? c : c - 'a' + 'A'; }
char toLower(const char &c) { return islower(c) ? c : c + 'a' - 'A'; }
bool isvowel(char c){  c = toLower(c);return (c == 'a' or c == 'e' or c == 'i' or c == 'i' or c == 'o' or c == 'u' || c == 'y');}
void toLowerCase(string &s){rep(s.size()){  if (!islower(s[i]))  {    s[i] = tolower(s[i]);  }}}
void toUpperCase(string &s){rep(s.size()) { s[i] = toupper(s[i]); }}
bool ispal(string s){  ll lo, hi;  lo = 0;  hi = s.length() - 1;  while (lo <= hi)  {    if (s[lo] != s[hi])    {      return 0;    }    lo++;    --hi;  }  return 1;}
template <class T>string toString(T n){  string v = "";  while (n)  {    v.pb(n % 10 + '0');    n /= 10;  }  reverse(all(v));  return v;}

// Maths
template <typename t>t gcd(t a, t b){  a = abs(a), b = abs(b);  return ((b == 0) ? a : gcd(b, a % b));}
template <typename t>t lcm(t a, t b) { return (a * (b / gcd(a, b))); }
template <typename T>T modpow(T base, T exp, T modulus){  base %= modulus;  T result = 1;  while (exp > 0)  {    if (exp & 1)      result = (result * base) % modulus;    base = (base * base) % modulus;    exp >>= 1;  }  return result;}
template <typename T>void cumulative(T *a, T *b, T n){  rep(n) { i ? b[i] = b[i - 1] + a[i] : b[i] = a[i]; }}

// Some constants
const int inf = 1e9 + 7;
const double eps = 1e-9;
const double pi = 1.00 * acos(-1.00);

//--------------


ll findCuts(double k, vi a, ll d) {
	int n = sz(a) - 1;
	ll cuts = 0;
	ll tot = 0;

	while(n >= 0) {
		ll can = floor(1.00 * a[n] / k);
		if(can == 0) break;

		if(tot + can <= d) {
			tot += can;
			if(1.00 * a[n] / double(can) <= k + eps) {
				cuts += can-1;
			}else {
				cuts += can;
			}
		}else {
			tot = d;
			cuts += (d - tot) - 1;
			break;
		}
		n--;
	}
	if(tot < d) return -1;
	return cuts;
}


// ll findCuts(ll k, vi a, ll d) {
// 	int n = 0;
// 	ll cuts = 0;
// 	ll tot = 0;

// 	while(n < sz(a)) {
// 		ll can = floor(a[n] / k);
// 		if(can == 0) {
// 			n ++;
// 			continue;
// 		}

// 		if(tot + can <= d) {
// 			tot += can;
// 			if(a[n] == k * can) {
// 				cuts += can-1;
// 			}else {
// 				cuts += can;
// 			}
// 		}else {
// 			tot = d;
// 			cuts += (d - tot);
// 			break;
// 		}
// 		n++;
// 	}
// 	if(tot < d) return -1;
// 	return cuts;
// }


// void solve() {
// 	ll t;
// 	cin >> t;
// 	ll cas = 0;
// 	while(t--) {
// 		ll n, d;
// 		cin >> n >> d;
// 		vi a(n);
// 		map<ll,ll> m;

// 		rep(n) {
// 			cin >>a[i];
// 			m[a[i]]++;
// 		}
		
// 		cout << "Case #" << ++cas << ": ";
			
// 		bool ok = 0;

// 		for(auto x: m) {
// 			if(x.sc >= d) {
// 				cout << 0 << endl;
// 				ok = 1;
// 				break;
// 			}
// 		}

// 		if(ok) continue;

// 		sort(all(a));
		
// 		if(n == 1) {
// 			cout << d-1 << endl;
// 		}else{
// 			ll ans = inf;
// 			ll lo =  a[0];
// 			ll hi =  a[n-1];
// 			while(lo < hi) {
// 				ll mid = (lo + hi) / 2;
// 				// cout << mid << endl;
// 				ll cuts = findCuts(mid, a, d);
// 				if(cuts == -1) {
// 					hi = mid;
// 				}else {
// 					ans = min(ans, cuts);
// 					lo = mid+1;
// 				}
// 			}
// 			cout << ans << endl;
// 		}
// 	}
// }

// vector<ll> dp[10001];

// ll findC(vi v, ll n, ll d) {

// 	if(n == 0) {
// 		return dp[n][d] = d - 1;
// 	}
// 	if(dp[n][d] != -1) return dp[n][d];
// 	ll ans = d - 1;
// 	for(int i = 1;i <= d; i++) {
// 		ans = min(ans, findC(v, n-1, i))
// 	}
// }

void solve() {
	ll x;
	cin >> x;
	ll t = 0;
	ll p = 100;
	while(p < x) {
		p = floor(1.00*p*1.01);
		t++;
	}
	cout<<t<< endl;
}

// ll getLong(string s) {
// 	return stoll(s);
// }

// void solve() {
// 	ll t;
// 	cin >> t;
// 	ll cas = 0;
// 	while(t-- ){
// 		ll u;
// 		cin >> u;
// 		std::vector<pair<string, string> > v;
// 		set<char> s;
// 		map<char, ll> greater, smaller;

// 		rep(10000) {
// 			string q, r;
// 			cin >> q >> r;
// 			if(q!="-1")
// 				v.pb(mp(r, q));
// 			rep(sz(r)) {
// 				s.insert(r[i]);
// 			}
// 		}
// 		if(s.size() < 10) {
// 			for(char c = 'A'; c <= 'Z' ; c++) {
// 				if(s.count(c))continue;
// 				s.insert(c);
// 				if(s.size() == 10)break;
// 			}
// 		}

// 		for(char c: s) {
// 			greater[c] = 0;
// 			smaller[c] = 9;
// 		}

// 		sort(all(v));

// 		rep(sz(v)) {
// 			// ll maxi = getLong(v[i].sc);
// 			string num = v[i].sc;
// 			string str =  v[i].fr;
// 			greater[str[0]] = 1;
// 			ll start = sz(v[i].sc) - sz(v[i].fr);
// 			if(start != 0){
// 				continue;
// 			}

// 			for(int j = 0 ; j < sz(str); j++) {
// 				if(smaller[str[j]] + '0' > num[j]) {
// 					smaller[str[j]] = num[j] - '0';
// 				}else break;
// 			}
// 		}

// 		char zer;

// 		for(auto x: greater) {
// 			if(x.sc == 0) {
// 				zer = x.fr;
// 				break;
// 			}
// 		}

// 		vector<pair<ll, char> > ae;
// 		for(auto x: smaller) {
// 			if(x.fr == zer) continue;
// 			ae.pb(mp(x.sc, x.fr));
// 		}

// 		sort(all(ae));

// 		cout << "Case #" << ": " << ++cas << ": ";
// 		cout << zer;
// 		rep(sz(ae)) {
// 			cout << ae[i].sc;
// 		}
// 		cout << endl;





// 	}
// }

int main() {
	#ifndef ONLINE_JUDGE
	freopen("input.txt", "r", stdin);
	// freopen("out.txt", "w", stdout);
	#else
	#endif

	solve();

	return 0;
}


// class protovEB{
// public:
// 	int U;
// 	protovEB *summary;
// 	vector<protovEB*> clusters;
	
// 	int root(int x) {
// 		return int(sqrt(x));
// 	}

// 	int high(int x) {
// 		return x / root(U);
// 	}

// 	int low(int x) {
// 		return x % root(U);
// 	}

// 	int index(int c, int i) {
// 		return c * root(U) + i;
// 	}

// 	protovEB(int u) {
// 		U = u;
// 		// Base case 
// 		if(U <= 2) {
// 			summary = NULL;
// 			clusters = std::vector<protovEB*>(U, NULL);
// 		} else {
// 			summary = new protovEB(root(U));
// 			clusters = std::vector<protovEB*>(root(U));
// 			for(int i = 0 ; i < root(U); i++) {
// 				clusters[i] = new protovEB(root(U));
// 			}
// 		}
// 	}
// };

// bool find(protovEB* root, int x) {
// 	if(x >= root->U) {
// 		return false;
// 	}

// 	if(root->U == 2) {
// 		return root->clusters[x];
// 	}
// 	return find(root->clusters[root->high(x)], root->low(x));
// }

// int minimum(protovEB* root) {
// 	if(root->U == 2) {
// 		if(root->clusters[0]) {
// 			return 0;
// 		}
// 		if(root->clusters[1]) {
// 			return 1;
// 		}
// 		return -1;
// 	}

// 	int clusterIdx = minimum(root->summary);
// 	if(clusterIdx == -1){
// 		return -1;
// 	} 

// 	int minValInCluster = minimum(root->clusters[clusterIdx]);
// 	return root->index(clusterIdx, minValInCluster);
// }

// int protovEB::successor(protovEB* root, int x) {
// 	if(root->U == 2) {
// 		if(x == 1) return -1;
// 		return (root->clusters[1]) ? 1 : -1;
// 	}

// 	int clusterIdx = successor(root->summary, root->high(x));

// 	if(clusterIdx == -1) return -1;

// 	int successorOffsetInCluster = minimum(root->clusters[clusterIdx]);

// 	return root->index(clusterIdx, successorOffsetInCluster);
// }


// int main() {

// 	SuperImpose* si = new SuperImpose();

// 	cout << si->minimum() << endl; // -1

// 	si->insert(10);
// 	si->insert(13);
// 	si->insert(3);
// 	si->insert(15);

// 	cout << si->find(10) << endl; // 1
// 	cout << si->find(13) << endl; // 1
// 	cout << si->find(12) << endl; // 0
// 	cout << si->find(15) << endl; // 1

// 	cout << si->minimum() << endl; // 3
// 	si->insert(2);
// 	cout << si->minimum() << endl; // 2

// 	cout << si->successor(3) << endl; // 10
// 	cout << si->successor(2) << endl; // 3
// 	cout << si->successor(5) << endl; // 10
// 	cout << si->successor(13) << endl; // 15
// 	cout << si->successor(15) << endl; // -1
// }





































Measured memory_bytes: 3748