stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std; 

long long dp[500000]; 

inline long long stoii(string s)

{

	long long res=0;

	for(int i=0; i<s.size(); i++)

		res*=10, res+=(s[i]-'0');

	return res;	

}

int main() 

{  

    string s;

    cin>>s;

    memset(dp, 0, sizeof(dp));

    dp[0]=1, dp[1]=1, dp[2]=2, dp[3]=4, dp[4]=8, dp[5]=16, dp[6]=32, dp[7]=64, dp[8]=128, dp[9]=256, dp[10]=512;

    long long ans=0;

    int len=s.size();

    for(int i=1; i<=len; i++)

    	for(int j=0; (j+i)<=len; j++)

    		ans+=(long long)(stoii(s.substr(j, i))*dp[j]*dp[len-i-j]);

	cout<<ans;

    return 0;  

}  


// Faster C++ solution for the same problem (measured speedup: 5.11410983158752x):
#include<bits/stdc++.h>

using namespace std;

int main() 

{

	string s;

	cin>>s;

	long long res=0;

	for(int t=0; t<(1<<(s.size()-1)); t++)

	{

		long long tmp=s[0]-'0';

		for(int i=0; i<s.size()-1; i++)

		{

			if(t&(1<<i))

				res+=tmp, tmp=0;

			tmp*=10, tmp+=s[i+1]-'0';

		}

		res+=tmp;

	}

	cout<<res;

	return 0;

}
// Slower C++ solution:
#include<iostream>

#include<cmath>

using namespace std;

int c[2]={0,1};

 

int main()

{

	int n,i=0,k,t;

	int s[3000]={0};

	cin>>n;

	if(n==0)

	{

		cout<<"0"<<endl;

		return 0;

	}

	while(n!=0)

	{

		k=n%(-2);

		t=n/(-2);

		if(k<0)

		{

			k=k-(-2);

			t++;

		}	

		i++;

		n=t;

		s[i]=c[k];	

	}

	for(;i>=1;i--)

		cout<<s[i]; 

	return 0; 

}

// Faster C++ solution for the same problem (measured speedup: 5.241245270251586x):
#include <stdio.h>

 

int num[50];

int main()

{

    int n;

    scanf("%d",&n);

    int cnt=0;

     if(n==0){

        printf("0\n");

        return 0;

    }

    while(n){

        if(n%2!=0){

            num[++cnt]=1;

            n=(n-1)/(-2);

        }else{

            num[++cnt]=0;

            n=n/(-2);

        }

    }

 

    for(int i=cnt;i>=1;i--)

        printf("%d",num[i]);

}
// Slower C++ solution:
#include<bits/stdc++.h>

#include<iostream>

#include<cstdio>

#include<cstring>

#include<string>

#include<algorithm>

#include<stack>

#include<queue>

#define INF 0x3f3f3f3f

#define lowbit(x) x & -x

#define lson root<<1,l,mid

#define rson root<<1|1,mid+1,r

using namespace std;

typedef long long ll;

const int mod=1e9+7;

const int N=2e5+5;

int a[N];

bool cmp(int a,int b){

    return a>b;

}

int main(){

#ifdef Mizp

    freopen("in.txt","r",stdin);

#endif

    int n;

    scanf("%d",&n);

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

        scanf("%d",&a[i]);

    }

    sort(a+1,a+1+n,cmp);

    ll sum=0;

    for(int i=2;i<=n;i++){

        sum+=a[(i+1)/2];

    }

    printf("%lld\n",sum);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.148603000838963x):
#include<stdio.h>

#include<algorithm>

using namespace std;

long long a[200010];

int t[200010];

int main()

{

    int n;

    long long ans=0;

    scanf("%d",&n);

    for(int i=0;i<n;i++)scanf("%lld",&a[i]);

    sort(a,a+n);

    t[n-1]=1;int j=n-1;

    for(int i=1;i<n;i++)

    {

    	if(t[j]==2)j--;

    	ans+=a[j];t[j]++;

    	

	}

	printf("%lld ",ans);

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

vector<int> a;

ll sum;

int main() {

    int n;

    cin >> n;

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

        int x;

        cin >> x;

        a.push_back(x);

    }

    sort(a.begin(), a.end());

    if (n > 1) {

        sum += a[n - 1];

    }

    int k = n - 2;

    for (n = n - 2; n >= 2; k--, n -= 2) {

        sum += a[k] * 2;

    }

    if (n == 1) {

        sum += a[k];

    }

    cout << sum << endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.229729295712456x):
#include<stdio.h>

#include<algorithm>

using namespace std;

long long a[200010];

int t[200010];

int main()

{

    int n;

    long long ans=0;

    scanf("%d",&n);

    for(int i=0;i<n;i++)scanf("%lld",&a[i]);

    sort(a,a+n);

    t[n-1]=1;int j=n-1;

    for(int i=1;i<n;i++)

    {

    	if(t[j]==2)j--;

    	ans+=a[j];t[j]++;

    	

	}

	printf("%lld ",ans);

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define INF 0x3f3f3f3f

#define maxn 200005

#define ll long long



void DBG() {

    cerr << "]\n";

}

template <class H, class... T> void DBG(H h, T... t) {

    cerr << h;

    if (sizeof...(t)) {

        cerr << ", ";

    }

    DBG(t...);

}

#define _DEBUG

#ifdef _DEBUG

#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)

#else

#define dbg(...) 0

#endif



int tt, n, k;

int a[maxn];



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);



    cin >> n;

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

        cin >> a[i];

    }

    sort(a + 1, a + n + 1);

    ll ans = 0;

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

        ans += a[n - i / 2];

    }



    cout << ans;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.274203728529165x):
#include<stdio.h>

#include<algorithm>

using namespace std;

long long a[200010];

int t[200010];

int main()

{

    int n;

    long long ans=0;

    scanf("%d",&n);

    for(int i=0;i<n;i++)scanf("%lld",&a[i]);

    sort(a,a+n);

    t[n-1]=1;int j=n-1;

    for(int i=1;i<n;i++)

    {

    	if(t[j]==2)j--;

    	ans+=a[j];t[j]++;

    	

	}

	printf("%lld ",ans);

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define maxn 200010

#define ll long long

using namespace std;

ll n,a[maxn],ans;

bool cmp(int aa,int bb){return aa>bb;}

int main(){

	scanf("%lld",&n);

	for(int i=1;i<=n;++i) scanf("%lld",&a[i]);

	sort(a+1,a+n+1,cmp);

	if(n&1){

		n=n/2;

		for(int i=1;i<=n;++i)

		ans+=(a[i]*2);

		ans-=a[1];

		ans+=a[n+1];

	}

	else{

		n=n/2;

		for(int i=1;i<=n;++i)

		ans+=(a[i]*2);

		ans-=a[1];

	}

	cout<<ans;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.158326284276063x):
#include<stdio.h>

#include<algorithm>

using namespace std;

long long a[200010];

int t[200010];

int main()

{

    int n;

    long long ans=0;

    scanf("%d",&n);

    for(int i=0;i<n;i++)scanf("%lld",&a[i]);

    sort(a,a+n);

    t[n-1]=1;int j=n-1;

    for(int i=1;i<n;i++)

    {

    	if(t[j]==2)j--;

    	ans+=a[j];t[j]++;

    	

	}

	printf("%lld ",ans);

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#include<algorithm>

using namespace std;

typedef long long ll;

const ll MAXN = 1e5+200;

int main(){

    ll a[MAXN] = {0};

    ll n;

    cin>>n;

    for(ll i = 0; i < n; i++){

      cin>>a[i];

    }

    ll k = a[0];

    ll sum = 0;

    for(int i= 0; i < n; i++){

      if(i == n -1){

        if(a[i] >= k){

          k = a[i];

        }

        sum+=k;

      }else{

        if(a[i] >= k){

          k = a[i];

        }else{

          sum += k - a[i];

          k = a[i];

        }

      }



    }

    cout<<sum<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.8046315136129665x):
#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<map>

#include<queue>

#include<set>

#include<stack>

#include<string>

#include<vector>

using namespace std;

typedef long long LL;

LL n;



vector<LL>v;

 LL sum=0;

LL b[100005]={0};

struct node

{

	 LL v,i;

};

bool cmp(const node a,const node b)

{ 

 return a.v<b.v;

}

struct node a[100005];

void bfs(LL index,LL t)

{

LL i=index;

	sum+=(t-b[i]);

	while(i>=0)

	 {

	 	 if(v[i]<t)

	 	 	break;

	 	 	b[i]=t;

			

		     i--;

	 }

	 i=index;

	 while(i<n)

	 {

	 	if(v[i]<t)

	 	 break;

		 

		b[i]=t;

		  i++;

	 }

 } 

int main()

{

 cin>>n;

  for(LL i=0;i<n;i++)

  {

  	cin>>a[i].v;

  	a[i].i=i;

  	v.push_back(a[i].v);

  }

 

  sort(a,a+n,cmp);

  for(LL i=0;i<n;i++)

  {

  	bfs(a[i].i,a[i].v);

//  	cout<<i<<" "<<a[i].v<<" "<<a[i].i<<endl;

//  	for(int i=0;i<n;i++)

//  	cout<<b[i]<<" ";

//  	cout<<"sum= "<<sum;

//  	cout<<"\n";

  }

//  for(int i=0;i<v.size();i++)

//  cout<<v[i]<<" ";

  cout<<sum;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main()

{

	int a;

	string s;

	cin >> a >> s;

	if(a >= 3200) cout << s << endl;

	else cout << "red" << endl;

}

// Faster C++ solution for the same problem (measured speedup: 5.269087052872891x):
#include<stdio.h>

int main(){

    int a;

    scanf("%d",&a);

    char s[100];

    scanf("%s",s);

    

    

    if(a>=3200)

    printf("%s",s);

    else

    printf("red");

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>



using namespace std;



int main()

{

	int a;

	string s;

	cin >> a;

	cin >> s;

	if(a >= 3200)

	{

		cout << s <<  endl;

	}

	else

	{

		cout << "red" << endl;

	}

}

// Faster C++ solution for the same problem (measured speedup: 5.2674403828586x):
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

const int maxd = 1e5+10;

char s[maxd];

int main()

{

	// freopen("a.in","r",stdin);

	// freopen("k.out","w",stdout);

	int x;

	scanf("%d %s",&x,s);

	if(x >= 3200) printf("%s",s);

	else printf("red");

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define ll long long

#define ull unsigned long long

#define IO ios::sync_with_stdio(false), cin.tie(0)

#define endl '\n'

#define pi acos(-1.0)

#define ms(a, x) memset(a, x, sizeof(a))

#define lowbit(x) ((x)&(-(x)))

#define pb push_back

#define binarycount __builtin_popcount(x)

#define tr t[root]

#define lson t[root << 1]

#define rson t[root << 1 | 1]

#define debug(x) cout<<x<<'\n'

#define pii pair<ll,pair<ll,ll> >

using namespace std;

const int inf = 0x3f3f3f3f;

const ll INF=0x3f3f3f3f3f3f3f3f;

const ll mod = 1e9+7;

const double eps = 1e-8;

ll gcd(ll a, ll b) {return b==0?a:gcd(b, a%b);}

ll lcm(ll a, ll b) {return a/gcd(a, b)*b;}

ll powmod(ll a,ll b){

    ll ans = 1, pow = a;

    while(b) { if(b&1) ans = (ans*pow)%mod; pow = (pow*pow)%mod; b >>= 1; }

    return ans;

}

ll mul(ll a,ll b){//大数取模乘法防止溢出

    ll ans=0;

    a%=mod,b%=mod;

    while(b) { if(b&1) ans = (ans+a)%mod; a = (a*2)%mod; b >>= 1; }

    return ans;

}

//(b/a)%p=b*a^(p-2)%p

int pr(ll num){//判断素数

     if(num == 1) return 0;

     if(num ==2|| num==3 ) return 1 ;

     if(num %6!= 1&&num %6!= 5) return 0 ;

     int tmp =sqrt( num);

     for(int i= 5;i <=tmp; i+=6 )

          if(num %i== 0||num %(i+ 2)==0 )return 0 ;

     return 1 ;

}

int Day(int y,int m, int d){

    if(m==1||m==2) { m+=12; y--; }

    int w=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;

    return w+1;

}

inline int read() {

    int c = 0, f = 1;

    char ch = getchar();

    while (ch < '0' || ch > '9') {

        if (ch == '-') f = -1;

        ch = getchar();

    }

    while (ch >= '0' && ch <= '9') {

        c = c * 10 + ch - '0';

        ch = getchar();

    }

    return c * f;

}



//#pragma comment(linker, "/STACK:1024000000,1024000000")//外挂开栈

//stable_sort 排序不处理相同元素

//map<int,int>::reverse_iterator rit;

//for(rit=mp.rbegin();rit!=mp.rend();rit++)

//vec动态二维数组

//vector<vector<int>> g(26,vector<int>(100005));

//初始化vec里面套了n个vec



//lower_bound(begin,end,num) 有序数列中返回第一个>=num的数字的地址

//upper_bound( begin,end,num) 返回第一个>num的数字的地址



const int maxn=1e5+5;

int main(){

    ll x,a=101;

    cin>>x;

    int cnt=0;

    while(a<x){

        a*=1.01;

        cnt++;

    }

    cout<<cnt+1<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.200750380104798x):
#include<stdio.h>

int main()

{

	long long n;

	scanf("%lld",&n);

	long long x=100,y,cnt=0;

	while(1)

	{

		y=x/100;

		x=x+y;

		cnt++;

		if(x>=n)

		break;

	}

	printf("%lld",cnt);

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){

	ll x;

	cin>>x;

	ll ans=100;

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

		ans+=(ans/100);

		if(ans>=x) {

			cout<<i;

			break;

		}

	}

	return 0;

} 

// Faster C++ solution for the same problem (measured speedup: 5.187097108369608x):
#include<stdio.h>

int main()

{

	long long n;

	scanf("%lld",&n);

	long long x=100,y,cnt=0;

	while(1)

	{

		y=x/100;

		x=x+y;

		cnt++;

		if(x>=n)

		break;

	}

	printf("%lld",cnt);

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 0x3f3f3f3f

const int N=1e5+5;

int main()

{

    ios::sync_with_stdio(false);

    ll x,ans=100;

    int i;

    scanf("%lld",&x);

    for(i=1;;i++)

    {

    	ans+=ans/100;

    	if(ans>=x)

    	{

    		printf("%d\n",i);

    		break;

		}

	}

    return 0; 

}

// Faster C++ solution for the same problem (measured speedup: 5.204693863655756x):
#include<stdio.h>

int main()

{

	long long n;

	scanf("%lld",&n);

	long long x=100,y,cnt=0;

	while(1)

	{

		y=x/100;

		x=x+y;

		cnt++;

		if(x>=n)

		break;

	}

	printf("%lld",cnt);

}
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#define ll long long

using namespace std;

int main()

{

	ll m,st=100;

	int len=0;

	cin >> m;

	while (st < m)

	{

		st = st*1.01;

		len++;

	}

	cout << len << endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.205326155982585x):
#include<stdio.h>

int main()

{

	long long n;

	scanf("%lld",&n);

	long long x=100,y,cnt=0;

	while(1)

	{

		y=x/100;

		x=x+y;

		cnt++;

		if(x>=n)

		break;

	}

	printf("%lld",cnt);

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define ll long long

#define ull unsigned long long

#define IO ios::sync_with_stdio(false), cin.tie(0)

#define endl '\n'

#define pi acos(-1.0)

#define ms(a, x) memset(a, x, sizeof(a))

#define lowbit(x) ((x)&(-(x)))

#define pb push_back

#define binarycount __builtin_popcount(x)

#define tr t[root]

#define lson t[root << 1]

#define rson t[root << 1 | 1]

#define debug(x) cout<<x<<'\n'

#define pii pair<ll,pair<ll,ll> >

using namespace std;

const int inf = 0x3f3f3f3f;

const ll INF=0x3f3f3f3f3f3f3f3f;

const ll mod = 1e9+7;

const double eps = 1e-8;

ll gcd(ll a, ll b) {return b==0?a:gcd(b, a%b);}

ll lcm(ll a, ll b) {return a/gcd(a, b)*b;}

ll powmod(ll a,ll b){

    ll ans = 1, pow = a;

    while(b) { if(b&1) ans = (ans*pow)%mod; pow = (pow*pow)%mod; b >>= 1; }

    return ans;

}

ll mul(ll a,ll b){//大数取模乘法防止溢出

    ll ans=0;

    a%=mod,b%=mod;

    while(b) { if(b&1) ans = (ans+a)%mod; a = (a*2)%mod; b >>= 1; }

    return ans;

}

//(b/a)%p=b*a^(p-2)%p

int pr(ll num){//判断素数

     if(num == 1) return 0;

     if(num ==2|| num==3 ) return 1 ;

     if(num %6!= 1&&num %6!= 5) return 0 ;

     int tmp =sqrt( num);

     for(int i= 5;i <=tmp; i+=6 )

          if(num %i== 0||num %(i+ 2)==0 )return 0 ;

     return 1 ;

}

int Day(int y,int m, int d){

    if(m==1||m==2) { m+=12; y--; }

    int w=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;

    return w+1;

}

inline int read() {

    int c = 0, f = 1;

    char ch = getchar();

    while (ch < '0' || ch > '9') {

        if (ch == '-') f = -1;

        ch = getchar();

    }

    while (ch >= '0' && ch <= '9') {

        c = c * 10 + ch - '0';

        ch = getchar();

    }

    return c * f;

}



//#pragma comment(linker, "/STACK:1024000000,1024000000")//外挂开栈

//stable_sort 排序不处理相同元素

//map<int,int>::reverse_iterator rit;

//for(rit=mp.rbegin();rit!=mp.rend();rit++)

//vec动态二维数组

//vector<vector<int>> g(26,vector<int>(100005));

//初始化vec里面套了n个vec



//lower_bound(begin,end,num) 有序数列中返回第一个>=num的数字的地址

//upper_bound( begin,end,num) 返回第一个>num的数字的地址



const int maxn=1e5+5;

int main(){

    ll x,a=101;

    cin>>x;

    int cnt=0;

    while(a<x){

        a*=1.01;

        cnt++;

    }

    cout<<cnt+1<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.164488054270022x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){

	ll x;

	cin>>x;

	ll ans=100;

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

		ans+=(ans/100);

		if(ans>=x) {

			cout<<i;

			break;

		}

	}

	return 0;

} 

// Faster C++ solution for the same problem (measured speedup: 5.150929980218279x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 0x3f3f3f3f

const int N=1e5+5;

int main()

{

    ios::sync_with_stdio(false);

    ll x,ans=100;

    int i;

    scanf("%lld",&x);

    for(i=1;;i++)

    {

    	ans+=ans/100;

    	if(ans>=x)

    	{

    		printf("%d\n",i);

    		break;

		}

	}

    return 0; 

}

// Faster C++ solution for the same problem (measured speedup: 5.168404041810789x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#define ll long long

using namespace std;

int main()

{

	ll m,st=100;

	int len=0;

	cin >> m;

	while (st < m)

	{

		st = st*1.01;

		len++;

	}

	cout << len << endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.169031925467965x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



#define forn(i, n) for (int i = 0; i < int(n); ++i)

#define for1(i, n) for (int i = 1; i <= int(n); ++i)

#define ms(a, x) memset(a, x, sizeof(a))

#define F first

#define S second

#define all(x) (x).begin(),(x).end()



using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

const int INF = 0x3f3f3f3f;

mt19937 gen(chrono::steady_clock::now().time_since_epoch().count());

template<typename... Args> void rd(Args&... args) {((cin >> args), ...);}

template<typename... Args> void write(Args... args) { ((cout << args << " "), ...); cout<<endl;}



int main() {

    ios::sync_with_stdio(false);

    cin.tie(nullptr);

    int ans=0;

    ll x;

    cin>>x;

    ll n=100;

    while(n<x){

        n=n*1.01;

        ans++;

    }

    cout<<ans;

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.276831878302944x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define ll long long

const int maxn = 2e5 + 100; 

const double pi = acos(-1.0);



inline ll read()

{

    ll kk=0,f=1;

    char cc=getchar();

    while(cc<'0'||cc>'9'){if(cc=='-')f=-1;cc=getchar();}

    while(cc>='0'&&cc<='9'){kk=(kk<<1)+(kk<<3)+cc-'0';cc=getchar();}

    return kk*f;

}





int main(void)

{

	ll x,num,ans=0;

	x=read();

//	scanf("%lf",&x);

//	ans = log(x/100)/log(1.01);

//	num = x/100;





	ll i=100;

//	printf("%lld",i);

	ll y=0;

	while(i<x)

	{

		i*=1.01;

		y++;

	}

	printf("%lld",y);

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.0969540891115335x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;

vector<ll>vec;

int main() 

{

    ll x;

    cin>>x;

    ll ans=0;

    ll p=100;

    for(;p<x;ans++)

    {

        p=p*(1.01);

    }

    cout<<ans<<endl;

    

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.166754789473879x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}
// Slower C++ solution:
#pragma region 

#include<iostream>

#include<algorithm>

#include<vector>

#include<stack>

#include<queue>

#include<map>

#include<cstring>

#include<string>

typedef long long ll;

template <typename T>void read(T &x){x=0;char ch=getchar();ll f=1;while(!isdigit(ch)){if(ch=='-')f*=-1;ch=getchar();}while(isdigit(ch)){x=x*10+ch-48;ch=getchar();}x*=f;}

#define IO ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)

using namespace std;

#pragma endregion



int main() {

    IO;

    ll x;

    cin >> x;

    int cnt = 0;

    ll now = 100;

    while (now<x) {

        now = (ll)(1.0 * now * 1.01);

        cnt++;

    }

    cout << cnt << endl;

}

// Faster C++ solution for the same problem (measured speedup: 5.235621295196562x):
#include<stdio.h>

int main(){

	long long x,y=100,i=0;

	scanf("%lld",&x);

	while(1) {

		y*=1.01;

		(long long)y;

		i++;

		if(y>=x) break;

	}

	printf("%lld",i);

	return 0;

}
// Slower C++ solution:
#pragma region 

#include<iostream>

#include<algorithm>

#include<vector>

#include<stack>

#include<queue>

#include<map>

#include<cstring>

#include<string>

typedef long long ll;

template <typename T>void read(T &x){x=0;char ch=getchar();ll f=1;while(!isdigit(ch)){if(ch=='-')f*=-1;ch=getchar();}while(isdigit(ch)){x=x*10+ch-48;ch=getchar();}x*=f;}

#define IO ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)

using namespace std;

#pragma endregion



int main() {

    IO;

    ll x;

    cin >> x;

    int cnt = 0;

    ll now = 100;

    while (now<x) {

        now = (ll)(1.0 * now * 1.01);

        cnt++;

    }

    cout << cnt << endl;

}

// Faster C++ solution for the same problem (measured speedup: 5.239709740673815x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}
// Slower C++ solution:
#include<iostream>

#include<math.h>

using namespace std;

int main()

{

	unsigned long long a=100;

	unsigned long long n,k=0;

	scanf("%lld",&n);

	while(a)

	{

		if(a>=n)

		break;

		a=a+a/100;

		k++;

	}

	printf("%lld",k);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.0963614656566465x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}
// Slower C++ solution:
#include"iostream"

#include"algorithm"

using namespace std;

int main()

{

	long long int n, flag = 0, cnt = 100;

	while (cin >> n) {

		for(;;) {

			cnt += cnt / 100;

			flag++;

			if ( cnt >= n ) {

				break;

			}

		}

		cout << flag << endl;

	}

	return 0;

} 

// Faster C++ solution for the same problem (measured speedup: 5.160283379016485x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main(){

	long long int a,b=100,c=0;

	cin>>a;

	while(b<a){

		b=b*1.01;

		c++;

	}

	cout<<c;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.157796939237171x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}
// Slower C++ solution:
#include<cstdio>

#include<cmath>

#include<iostream>

using namespace std;

int main()

{

    long long sum[60000],a,b;

    sum[0]=100;

    scanf("%lld",&a);

    for(b=1;1;b++){

    sum[b]=sum[b-1]/100+sum[b-1];

    if(sum[b]>=a) break;

    }

    printf("%lld",b);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.21020793381696x):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}