#include <stdio.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <utility>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstdio>
using namespace std;
 
int main(){
    string S;
    cin>>S;
    int N=S.size();
    int d[10]={0};
    int flag=0;
    for(int i=0;i<N;++i){
        d[S[i]-'0']++;
    }
    if(N==1){
        if(d[8]==1){
            flag=1;
        }
    }
    else if(N==2){
        if((d[2]==1)&&(d[3]+d[7]==1)){
            flag=1;
        }
        if((d[4]==1)&&(d[2]+d[6]==1)){
            flag=1;
        }
        if((d[6]==1)&&(d[1]+d[5]+d[9]==1)){
            flag=1;
        }
        if((d[8]==2)||((d[4]==1)&&(d[8]==1))){
            flag=1;
        }
    }
    else{
        if(d[2]){
            if(d[1]+d[5]+d[9]){
                if(d[1]+d[3]+d[5]+d[7]+d[9]-1){
                    flag=1;
                }
            }
            if(d[3]+d[7]){
                if(d[2]+d[4]+d[6]+d[8]-1){
                    flag=1;
                }
            }
        }
        if(d[4]){
            if(d[4]+d[8]-1){
                if(d[1]+d[3]+d[5]+d[7]+d[9]){
                    flag=1;
                }
            }
            if(d[2]+d[6]){
                if(d[2]+d[4]+d[6]+d[8]-2){
                    flag=1;
                }
            }
        }
        if(d[6]){
            if(d[3]+d[7]){
                if(d[1]+d[3]+d[5]+d[7]+d[9]-1){
                    flag=1;
                }
            }
            if(d[1]+d[5]+d[9]){
                if(d[2]+d[4]+d[6]+d[8]-1){
                    flag=1;
                }
            }
        }
        if(d[8]){
            if(d[2]+d[6]){
                if(d[1]+d[3]+d[5]+d[7]+d[9]){
                    flag=1;
                }
            }
            if(d[4]+d[8]-1){
                if(d[2]+d[4]+d[6]+d[8]-2){
                    flag=1;
                }
            }
        }
    }
    if(flag==1){
        cout<<"Yes"<<endl;
    }
    else{
        cout<<"No"<<endl;
    }
    return 0;
}
#include <bits/stdc++.h>
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("inline")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #define DEBUG

#ifdef DEBUG
#pragma region
#endif

using namespace std;
#define LL long long
#define PII pair<int, int>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define newl '\n'
#ifdef DEBUG
#define debug(...) cerr << '[', _debug(__VA_ARGS__)
#else
#define debug(...)
#endif

const int INF = 1e9;

template <typename T>
void _debug(T a) {
  cerr << a << ']' << endl;
}

template <typename T, typename... Args>
void _debug(T a, Args... args) {
  cerr << a << ", ";
  _debug(args...);
}

#ifdef DEBUG
#pragma endregion
#endif

string s;
int a[10];

void solve() {
  cin >> s;
  for (char c : s) {
    ++a[c - '0'];
  }
  if (s == "8") {
    cout << "Yes";
    return;
  }
  for (int i = 12; i < 100; i += 4) {
    int ten = i / 10, digit = i % 10;
    if (a[ten] >= 1) {
      --a[ten];
      if (a[digit] >= 1) {
        debug(ten, digit);
        --a[digit];

        if (s.size() == 2) {
          cout << "Yes";
          return;
        } else {
          if (i % 8 == 0) {
            if (a[2] >= 1 || a[4] >= 1 || a[6] >= 1 || a[8] >= 1) {
              cout << "Yes";
              return;
            }
          } else {
            if (a[1] >= 1 || a[3] >= 1 || a[5] >= 1 || a[7] >= 1 || a[9] >= 1) {
              cout << "Yes";
              return;
            }
          }
        }

        ++a[digit];
      }
      ++a[ten];
    }
  }
  cout << "No";
}

int main() {
  // freopen("live.in", "r", stdin);
  // freopen("live.out", "w", stdout);
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  // cout << fixed << setprecision(7);
  // int n;
  // cin >> n;
  // rep(i, n)
  //     //
  solve();
  cout << flush;
}
