//dsu,modint,segtree,fenwick_tree,ntt,convolution,FPS
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <numeric>
#include <functional>
#include <tuple>
#include <limits>
#include <deque>
#include <unordered_set>
#include <unordered_map>
#include <cstring>
#include <sstream>
#include <utility>
#include <bitset>
#include <array>
#include <cstdint>
#include <cassert>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define REP(i,l,r) for(int i=l;i<(r);++i)
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define el "\n"
template<int MOD>// MOD is prime.
struct modint {
    long long x;
    modint (long long v=0){
        x=v%MOD;
        if(x<0)x+=MOD;
    }
    int val()const{
        return x;
    }
    modint&operator+=(const modint&a){
        x+=a.x;
        if(x>=MOD)x-=MOD;
        return *this;
    }
    modint&operator*=(const modint&a){
        x=x*a.x%MOD;
        return *this;
    }
    modint&operator-=(const modint&a){
        x-=a.x;
        if(x<0)x+=MOD;
        return *this;
    }
    modint operator+(const modint&a)const{
        modint res=*this;
        return res+=a;
    }
    modint operator-(const modint &a)const{
        modint res = *this;
        return res-=a;
    }
    modint operator*(const modint&a)const{
        modint res=*this;
        return res*=a;
    }
    modint pow(long long n)const{
        modint a=*this;
        modint res=1;
        while(n){
            if(n&1)res*=a;
            a*=a;
            n>>=1;
        }
        return res;
    }
    modint inv() const{
        return pow(MOD-2);//MOD is prime.
    }
    modint&operator/=(const modint&a){
        return *this*=a.inv();
    }
    modint operator/(const modint&a)const{
        modint res = *this;
        return res/=a;
    }
    modint operator-() const{
        return modint(-x);
    }
    bool operator==(const modint&a)const{
        return x==a.x;
    }
    bool operator!=(const modint&a)const{
        return x!=a.x;
    }
};
using mint = modint<998244353>;
////////////



//NTT
void ntt(vector<mint>&a,bool inverse){
    int n = a.size();
    for(int i=1,j=0;i<n;i++){
        int bit =n>>1;
        while(j&bit){
            j^=bit;
            bit>>=1;
        }
        j^=bit;
        if(i<j){
            swap(a[i],a[j]);
        }
    }
    for(int len=2;len<=n;len<<=1){
        mint wlen=mint(3).pow((998244353-1)/len);
        if(inverse){
            wlen=wlen.inv();
        }
        for(int i=0;i<n;i+=len){
            mint w=1;
            for(int j=0;j<len/2;j++){
                mint u=a[i+j];
                mint v=a[i+j+len/2]*w;
                a[i+j]=u+v;
                a[i+j+len/2]=u-v;
                w*=wlen;
            }
        }
    }
    if(inverse){
        mint inv_n=mint(n).inv();
        for(auto &x:a){
            x*=inv_n;
        }
    }
}
//convolution
vector<mint> convolution(vector<mint>a,vector<mint> b){
    if(a.empty()||b.empty()){
        return {};
    }
    int need=a.size()+b.size()-1;
    int n=1;
    while(n<need){
        n<<=1;
    }
    a.resize(n);b.resize(n);
    ntt(a,false);
    ntt(b,false);
    rep(i,n){
        a[i]*=b[i];
    }
    ntt(a,true);
    a.resize(need);
    return a;
}
//////

using vm = vector<mint>;
struct FPS:vm{
    #define d (*this)
    #define s int(size())
    using vm::vector;
    FPS(initializer_list<mint>a):vm(a){}
    FPS low(int n)const{
        FPS r=d;r.resize(n);return r;
    }
    mint&operator[](int i){
        if(i>=s)resize(i+1);
        return vm::operator[](i);
    }
    mint operator[](int i)const{
        return i<s?vm::operator[](i):0;
    }
    FPS operator-()const{
        FPS r=d;
        for(auto&x:r)x=-x;
        return r;
    }
    FPS&operator+=(const FPS&f){
        resize(max(s,(int)f.size()));
        for(int i=0;i<(int)f.size();i++)d[i]+=f[i];
        return d;
    }
    FPS&operator-=(const FPS&f){
        resize(max(s,(int)f.size()));
        for(int i=0;i<(int)f.size();i++)d[i]-=f[i];
        return d;
    }
    FPS& operator=(const vm&a){
        vm::operator=(a);
        return *this;
    }
    FPS&operator*=(const FPS&f){
        return d=convolution(d,f);
    }
    FPS operator+(const FPS&f)const{return FPS(d)+=f;}
    FPS operator-(const FPS&f)const{return FPS(d)-=f;}
    FPS operator*(const FPS&f)const{return FPS(d)*=f;}
    FPS&operator*=(mint x){
        for(auto &y:d)y*=x;
        return d;
    }
    FPS&operator/=(mint x){
        return d*=x.inv();
    }
    FPS operator*(mint x)const{return FPS(d)*=x;}
    FPS operator/(mint x)const{return FPS(d)/=x;}
    FPS inv(int n)const{
        FPS g={d[0].inv()};
        for(int m=1;m<n;m<<=1)g=(g*(FPS{2}-low(m<<1)*g)).low(m<<1);
        return g.low(n);
    }
    FPS& operator/=(const FPS&f){
        int n=s;
        return d=(d*f.inv(n)).low(n);
    }
    FPS operator/(const FPS&f)const{return FPS(d)/=f;}
    FPS diff() const{
        FPS r(max(0,s-1));
        for(int i=1;i<s;i++)r[i-1]=d[i]*i;
        return r;
    }
    FPS integral()const{
        FPS r(s+1);
        for(int i=0;i<s;i++)r[i+1]=d[i]/(i+1);
        return r;
    }
    FPS log(int n)const{
        return (diff()*inv(n)).low(n-1).integral().low(n);
    }
    //f[0]=0が必要
    //低性能のexp
    FPS exp(int n)const{
        FPS g={1};
        for(int m=1;m<n;m<<=1){
            int sz=min(n,m<<1);
            FPS q=low(sz);
            q-=g.log(sz);
            q+=this->low(sz);
            q[0]+=1;
            g=(g*q).low(sz);
        }
        return g.low(n);
    }
    FPS pow(long long k,int n)const{
        if(n==0)return {};
        if(k==0){
            FPS res(n);
            res[0]=1;
            return res;
        }
        int v=0;
        while(v<s&&d[v]==0)v++;
        if(v==s)return FPS(n);
        if(v>(n-1)/k)return FPS(n);
        int shift=v*k;
        int need=n-shift;
        mint c=d[v];
        FPS h;
        h.resize(s-v);
        for(int i=v;i<s;i++){
            h[i-v]=d[i]/c;
        }
        FPS res=(h.log(need)*mint(k)).exp(need);
        res*=c.pow(k);
        FPS ans(n);
        for(int i=0;i<need;i++){
            ans[i+shift]=res[i];
        }
        return ans;
    }
#undef d
#undef s

};
struct dsu{
    vector<int> p,sz;
    int group_count;
    dsu(int n):p(n),sz(n,1),group_count(n){
        iota(p.begin(),p.end(),0);
    }
    int leader(int x){
        if(p[x]==x)return x;
        return p[x]=leader(p[x]);
    }
    bool merge(int a,int b){
        a=leader(a);
        b=leader(b);
        if(a==b)return false;
        if(sz[a]<sz[b])swap(a,b);
        p[b]=a;
        sz[a]+=sz[b];
        group_count--;
        return true;
    }
    bool same(int a,int b){
        return leader(a)==leader(b);
    }
    int size(int x){
        return sz[leader(x)];
    }
    int groups(){
        return group_count;
    }
};
//Rotates an N*N vector<string> 90 degree clockwise rotation(In-place)
void rotate90(vector<string>&S){
    int N = S.size();
    for(int i=0;i<N;i++)for(int j=i+1;j<N;j++)swap(S[i][j],S[j][i]);
    for(int i=0;i<N;i++)for(int j=0;j<N/2;j++)swap(S[i][j],S[i][N-1-j]);
}
//Rotates an N*N vector<string> 270 degree clockwise rotation(In-place)
void rotate270(vector<string>&S){
    int N=S.size();
    for(int i=0;i<N;i++)for(int j=0;j<N/2;j++)swap(S[i][j],S[i][N-1-j]);
    for(int i=0;i<N;i++)for(int j=i+1;j<N;j++)swap(S[i][j],S[j][i]);
}
template<class S,S(*op)(S,S),S (*e)()>
struct segtree{
    public:
    segtree() : segtree(0){}
    explicit segtree(int n) : segtree(vector<S>(n,e())){}
    explicit segtree(const vector<S>&v) : _n(int(v.size())){
        size=1;
        while(size<_n)size<<=1;
        d=vector<S> (2*size,e());
        for(int i=0;i<_n;i++)d[size+i]=v[i];
        for(int i=size-1;i>=1;i--)update(i);
    }
    void set(int p,S x){
        assert(0<=p&&p<_n);
        p+=size;
        d[p]=x;
        while(p>>=1)update(p);
    }
    S get(int p)const{
        assert(0<=p&&p<_n);
        return d[p+size];
    }
    S prod(int l,int r)const{
        assert(0<=l&&l<=r&&r<=_n);
        S sml = e(),smr = e();
        l+=size;r+=size;
        while(l<r){
            if(l&1)sml=op(sml,d[l++]);
            if(r&1)smr=op(d[--r],smr);
            l>>=1;
            r>>=1;
        }
        return op(sml,smr);
    }
    S all_prod() const {return d[1];}

    template<bool(*f)(S)> int max_right(int l)const{
        return max_right(l,[](S x){return f(x);});
    }
    template<class F> int max_right(int l,F f)const{
        assert(0<=l&&l<=_n);
        assert(f(e()));
        if(l==_n)return _n;
        l+=size;
        S sm=e();
        do{
            while(l%2==0)l>>=1;
            if(!f(op(sm,d[l]))){
                while(l<size){
                    l=(2*l);
                    if(f(op(sm,d[l]))){
                        sm=op(sm,d[l]);
                        l++;
                    }
                }
                return l-size;
            }
            sm=op(sm,d[l]);
            l++;
        }while((l&-l)!=l);
        return _n;
    }
    template<bool(*f)(S)> int min_left(int r) const{
        return min_left(r,[](S x){return f(x);});
    }
    template<class F> int min_left(int r,F f)const{
        assert(0<=r&&r<=_n);
        assert(f(e()));
        if(r==0)return 0;
        r+=size;
        S sm=e();
        do{
            r--;
            while(r>1&&(r%2))r>>=1;
            if(!f(op(d[r],sm))){
                while(r<size){
                    r=(2*r+1);
                    if(f(op(d[r],sm))){
                        sm=op(d[r],sm);
                        r--;
                    }
                }
                return r+1-size;
            }
            sm=op(d[r],sm);
        }while((r&-r)!=r);
        return 0;
    }
    private:
    int _n,size;
    vector<S> d;
    void update(int k){
        d[k]=op(d[2*k],d[2*k+1]);
    }
};
template<class T>
struct fenwick_tree{
    int n;vector<T>data;
    fenwick_tree(int n):n(n),data(n+1,0){}
    //A[p]+=x
    void add(int p,T x){
        for(p++;p<=n;p+=p&-p){
            data[p]+=x;
        }
    }
    //A[0]+...+A[r-1]
    T sum(int r){
        T res=0;
        for(;r>0;r-=r&-r){
            res+=data[r];
        }
        return res;
    }
    // A[l]+...+A[r-1]
    T sum(int l,int r){
        return sum(r)-sum(l);
    }
    //fenwick_tree<ll> fw(N);
    //fw.add(3,10); //A[3]+=10;
    //cout << fw.sum(2,6)<<el;//[2,6)の区間和
};

template<class mint>
struct Comb{
    vector<mint> fact,ifact;
    Comb(int N):fact(N+1),ifact(N+1){
        fact[0]=1;
        for(int i=1;i<=N;i++){
            fact[i]=fact[i-1]*i;
        }
        ifact[N]=fact[N].inv();
        for(int i=N;i>=1;i--){
            ifact[i-1]=ifact[i]*i;
        }
    }
    // nCr
    mint C(int n,int r){
        if(r<0||n<r)return 0;
        return fact[n]*ifact[r]*ifact[n-r];;
    }
    //nPr
    mint P(int n,int r){
        if(r<0||n<r)return 0;
        return fact[n]*ifact[n-r];
    }
    //nHr
    mint H(int n,int r){
        if(n==0&&r==0)return 1;
        if(r<0)return 0;
        return C(n+r-1,r);
    }
};
using ll = long long;
using vi = vector<int>;
using vb = vector<bool>;
using vll = vector<ll>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<ll>>;
using vvb = vector<vector<bool>>;
using pii = pair<int, int>;
template<class T> using pq = priority_queue<T>;
template<class T> using pq_gt = priority_queue<T, vector<T>, greater<T>>;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b;return true; }return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b;return true; }return false; }
const ll INF = 1LL << 60;
//上右下左
const int dy4[4]={-1,0,1,0};
const int dx4[4]={0,1,0,-1};
//左上、上、右上、右、右下、下、左下、左
const int dy8[8]={-1,-1,-1,0,1,1,1,0};
const int dx8[8]={-1,0,1,1,1,0,-1,-1};
struct Sieve{
    int n;vector<int>f,primes;
    Sieve(int n=1):n(n),f(n+1){
        f[0]=f[1]=-1;
        for(long long i=2;i<=n;i++){
            if(f[i])continue;
            primes.push_back(i);
            f[i]=i;
            for(long long j=i*i;j<=n;j+=i){
                if(!f[j])f[j]=i;
            }
        }
    }
    bool isPrime(int x){return f[x]==x;}
    vector<int> factorList(int x){
        vector<int> res;
        while(x!=1){
            res.push_back(f[x]);
            x/=f[x];
        }
        return res;
    }
    vector<pair<int,int>> factor(int x){
        vector<int> fl = factorList(x);
        if(fl.size()==0)return {};
        vector<pair<int,int>> res(1,pair<int,int>(fl[0],0));
        for(int p:fl){
            if(res.back().first==p){
                res.back().second++;
            }else{
                res.emplace_back(p,1);
            }
        }
        return res;
    }
    vector<pair<long long,int>> factor(long long x){
        vector<pair<long long,int>> res;
        for(int p:primes){
            int y =0;
            while(x%p==0)x/=p,++y;
            if(y!=0)res.emplace_back(p,y);
        }
        if(x!=1)res.emplace_back(x,1);
        return res;
    }
};
ll pw(ll x,ll p){
    ll res=1;
    rep(i,p)res*=x;
    return res;
}
////////////////////
int op(int a,int b){
    return max(a,b);
}
int e(){
    return -1;
}
int v;
bool f(int seg_val){return seg_val<v;}
////////////////////






int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

    string N;cin >> N;
    bool ok=false;
    rep(i,N.size()-1){
        if(ok==true){
            cout << 5;
        }else{
            if(N[i]-'0'<=3){
                ok=true;
                continue;
            }else{
                if(N[i]-'0'==4){
                    if(N[i+1]-'0'<=3){
                        continue;
                        ok=true;
                    }else{
                        cout <<4;
                    }
                }
                if(N[i]-'0'==5){
                    if(N[i+1]-'0'<=3){
                        cout << 4;
                        ok=true;
                        continue;
                    }else{
                        cout << 5;
                    }
                }
            }
        }
    }
    if(ok){
        cout << 5;
    }else{
        cout << 4;
    }



    return 0;
}
//---
//Comb//Comb<mint> com(N);
//comb.C(n,r);nCr//comb.C(n,r).val() nCr<mint>
//---
//vs S//rotate90(S)//rotate270(S)
//---
//dy4,dx4//上右下左//dy8,dx8左上から時計回り
//---
//Sieve sv(N);//N以下の素数を前計算
//sv.isPrime(x);//xが素数か
//sv.factorList(x);//素因数を重複込みで返す
//sv.factor(x);//素因数分解を(p,指数)で返す。
//auto v = sv.factor(360) -> v = {{2,3}{3,2}{5,1}}