//  [cpp]
#include <iostream> // cin, cout, cerr
#include <algorithm> // minmax, sort, swap
#include <numeric> // iota
#include <cstdio> // printf, scanf
#include <string> // string, stoi, to_string
#include <vector> // vector
#include <queue> // queue, priority_queue
#include <deque> // deque
#include <map> // key-value pairs sorted by keys
#include <set> // set
#include <iomanip> // cout<<setprecision(n)
#include <functional> // function<void(int)>
#include <cmath>
#include <cassert>
#include <bitset>
#include <stack>

#ifdef DEBUG
#include "debug.hpp"
#else
#define debug(...)
#endif

#define int long long // at least int64 > 9*10^18
#define EL '\n'
#define rep(i,n) for(int i = 0; i < (n); i++)
#define print(i) std::cout << (i) << '\n'
#define all(v) (v).begin(), (v).end()
using Graph = std::vector<std::vector<int> >;
const int INF = 1e17;
/* libraries */

struct ulnt
{
    using uint64 = unsigned long long;
    static constexpr int N=2000;
    static constexpr uint64 mask=~(1ll<<63);
    int size=0;
    std::vector<uint64> data; // each unit is 63 bits
    ulnt() : data(N,0) {}
    ulnt(const ulnt& a) {
        data = a.data;
        size = a.size;
    }
    ulnt(std::string s) : data(N,0) {
        constexpr uint64 M = 1e18;
        uint64 tmp=0;
        int i=0;
        for(char c:s) {
            i++;
            int x=c-'0';
            tmp*=10;
            tmp+=x;
            if(i>=18) {
                this->mul(M);
                this->add(tmp);
                tmp=0; i=0;
            }
        }
        int m=1;
        for(int j=0;j<i;j++) { m*=10; }
        this->mul(m);
        this->add(tmp);
    }
    ulnt(uint64 x) : data(N,0) {
        if(x==0) return;
        data[0]=x&mask;
        data[1]=x>>63;
        if(data[1]!=0) size=2;
        else size=1;
    }
    ulnt assign(const ulnt& rhs) {
        data = rhs.data;
        size = rhs.size;
        return *this;
    }
    ulnt add(const ulnt& rhs) {
        int M=std::max(size,rhs.size)+1;
        uint64 carry=0; // 0 or 1
        for(int i=0;i<M;i++) {
            data[i]+=rhs.data[i]+carry;
            carry=data[i]>>63;
            data[i]&=mask;
        }
        while(M>0 && data[M-1]==0) M--;
        size=M;
        return *this;
    }
    int compare(const ulnt& rhs) const {
        if(size!=rhs.size) return (size<rhs.size)?-1:1;
        for(int i=size-1;i>=0;i--) {
            if(data[i]!=rhs.data[i]) {
                return (data[i]<rhs.data[i])?-1:1;
            }
        }
        return 0;
    }
    ulnt sub(const ulnt& rhs) {
        if(this->compare(rhs)<0) {
            std::cerr << "Underflow of lnt" << '\n';
            exit(1);
        }
        uint64 borrow=0; // 0 or 1
        for(int i=0;i<size;i++) {
            if(data[i]>=rhs.data[i]+borrow) {
                data[i]-=rhs.data[i]+borrow;
                borrow=0;
            } else {
                data[i]+=1ll<<63;
                data[i]-=rhs.data[i]+borrow;
                borrow=1;
            }
        }
        return *this;
    }
    void clear() {
        size=0;
        data.assign(N,0);
    }
    ulnt mul(const ulnt rhs) {
        ulnt tmp;
        for(int i=0;i<rhs.size*63;i++) {
            if(rhs.bit(i)) {
                tmp.add(*this);
            }
            this->bitwiseshift(1);
        }
        return this->assign(tmp);
    }
    ulnt div(const ulnt& rhs) {
        if(rhs.size==0) {
            std::cerr << "Division by zero" << '\n';
            exit(1);
        }
        ulnt r,d;
        for(int i=size*63;i>=0;i--) {
            r.bitwiseshift(1);
            d.bitwiseshift(1);
            r.bitwiseor(this->bit(i));
            if(r.compare(rhs)>=0) {
                r.sub(rhs);
                d.bitwiseor(1);
            }
        }
        return this->assign(d);
    }
    ulnt mod(const ulnt& rhs) const {
        if(rhs.size==0) {
            std::cerr << "Division by zero" << '\n';
            exit(1);
        }
        ulnt r,d;
        for(int i=size*63;i>=0;i--) {
            r.bitwiseshift(1);
            d.bitwiseshift(1);
            r.bitwiseor(this->bit(i));
            if(r.compare(rhs)>=0) {
                r.sub(rhs);
                d.bitwiseor(1);
            }
        }
        return r;
    }
    uint64 modull(const uint64 rhs) const {
        if(rhs==0) {
            std::cerr << "Division by zero" << '\n';
            exit(1);
        }
        uint64 r=0;
        for(int i=size*63;i>=0;i--) {
            r<<=1;
            r|=this->bit(i);
            if(r>=rhs) r-=rhs;
        }
        return r;
    }
    ulnt pow(uint64 k) {
        ulnt A(1), B(*this);
        while(k) {
            if(k&1) A.mul(B);
            B.mul(B);
            k>>=1;
        }
        return A;
    }
    ulnt bitwiseshift(const int k) {
        if(k==0) return *this;
        if(size==0) return *this;
        if(k>0) {
            int blocks = k/63;
            int bits = k%63;
            for(int i=size;i>=0;i--) {
                data[i+1+blocks]|=data[i]>>(63-bits);
                data[i+blocks]=(data[i]<<bits)&mask;
            }
            for(int i=blocks-1;i>=0;i--) {
                data[i]=0;
            }
            size+=blocks+1;
            while(size>0 && data[size-1]==0) size--;
        } else {
            int blocks = -k/63;
            int bits = -k%63;
            for(int i=0;i<size;i++) {
                data[i]=data[i+blocks]>>bits;
                data[i]|=(data[i+1+blocks]<<(63-bits))&mask;
            }
            for(int i=size-blocks;i<size;i++) {
                data[i]=0;
            }
            size-=blocks;
            while(size>0 && data[size-1]==0) size--;
        }
        return *this;
    }
    ulnt bitwiseor(const ulnt& rhs) {
        for(int i=0;i<rhs.size;i++) {
            data[i]|=rhs.data[i];
        }
        size=std::max(size,rhs.size);
        return *this;
    }
    ulnt bitwiseand(const ulnt& rhs) {
        for(int i=0;i<size;i++) {
            data[i]&=rhs.data[i];
        }
        size=std::min(size,rhs.size);
        while(size>0 && data[size-1]==0) size--;
        return *this;
    }
    ulnt bitwisexor(const ulnt& rhs) {
        for(int i=0;i<std::max(size,rhs.size);i++) {
            data[i]^=rhs.data[i];
        }
        size=std::max(size,rhs.size);
        while(size>0 && data[size-1]==0) size--;
        return *this;
    }
    bool bit(const int i) const {
        int blocks = i/63;
        int bits = i%63;
        return data[blocks]>>bits&1;
    }
};
std::istream& operator>>(std::istream&i,ulnt&a) {
    unsigned long long t; i>>t; a=ulnt(t); return i;
}
std::ostream& operator<<(std::ostream&o,const ulnt&a) {
    using uint64 = unsigned long long;
    if(a.size==0) {o<<0; return o; }
    ulnt b = a;
    constexpr uint64 MOD = 1e18;
    std::stack<uint64> stk;
    while(b.size) {
        stk.emplace(b.modull(MOD));
        b.div(MOD);
    }
    o<<stk.top(); stk.pop();
    while(!stk.empty()) {
        uint64 x = stk.top(); stk.pop();
        o<<std::setfill('0')<<std::setw(18)<<x;
    }
    return o;
}


signed main() {
	int x;
	std::cin >> x;
	ulnt xx=x;
	ulnt s=100;
	int i=0;
	while(s.compare(xx)<0) {
		s.mul(101);
		s.div(100);
		i++;
	}
	print(i);
	return 0;
}