Top-model Izabella participates in the competition. She wants to impress judges and show her mathematical skills.

Her problem is following: for given string, consisting of only 0 and 1, tell if it's possible to remove some digits in such a way, that remaining number is a representation of some positive integer, divisible by 64, in the binary numerical system.
In the only line given a non-empty binary string *s* with length up to 100.
In the first test case, you can get string 1 000 000 after removing two ones which is a representation of number 64 in the binary numerical system.

You can read more about binary numeral system representation here: [https://en.wikipedia.org/wiki/Binary_system](https://en.wikipedia.org/wiki/Binary_system)
100010001
yes
100
no
0000001000000
yes
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
no
1111111111111111111111111111111111111111111111111111111111111111111111110111111111111111111111111111
no
0111111101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
no
1111011111111111111111111111110111110111111111111111111111011111111111111110111111111111111111111111
no
1111111111101111111111111111111111111011111111111111111111111101111011111101111111111101111111111111
yes
0110111111111111111111011111111110110111110111111111111111111111111111111111111110111111111111111111
yes
1100110001111011001101101000001110111110011110111110010100011000100101000010010111100000010001001101
yes
000000
no
0001000
no
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
no
1000000
yes
0
no
1
no
10000000000
yes
0000000000
no
0010000
no
000000011
no
000000000
no
00000000
no
000000000011
no
0000000
no
00000000011
no
000000001
no
000000000000000000000000000
no
0000001
no
00000001
no
00000000100
no
00000000000000000000
no
0000000000000000000
no
00001000
no
0000000000010
no
000000000010
no
000000000000010
no
0100000
no
00010000
no
00000000000000000
no
00000000000
no
000001000
no
000000000000
no
100000000000000
yes
000010000
no
00000100
no
0001100000
no
000000000000000000000000001
no
000000100
no
0000000000001111111111
no
00000010
no
0001110000
no
0000000000000000000000
no
000000010010
no
0000100
no
0000000001
no
000000111
no
0000000000000
no
000000000000000000
no
0000000000000000000000000
no
000000000000000
no
0010000000000100
yes
0000001000
no
00000000000000000001
no
100000000
yes
000000000001
no
0000011001
no
000
no
000000000000000000000
no
0000000000011
no
0000000000000000
no
00000000000000001
no
00000000000000
no
0000000000000000010
no
00000000000000000000000000000000000000000000000000000000
no
000011000
no
00000011
no
0000000000001100
no
00000
no
000000000000000000000000000111111111111111
no
000000010
no
00000000111
no
000000000000001
no
0000000000000011111111111111111
no
0000000010
no
0000000000000000000000000000000000000000000000000
no
00000000010
no
101000000000
yes
00100000
no
00000000000001
no
0000000000100
no
0000
no
00000000000111
no
0000000000000011
no
0000000000000000000000000000000000000000
no
0000000000000010
no
0010101010
no
0000000000000001
no
1010101
no
#include<bits/stdc++.h>
#include<string.h>
#define ll long long int
#define fio ios_base::sync_with_stdio(false); cin.tie(NULL);
#define MAX_LIMIT 10000000
#define haha(x) x.begin(),x.end()
#define rs resize
#define remove_zero(str) str.erase(0, str.find_first_not_of('0'));
#define br break
const long long kot = LLONG_MAX;
#define pb push_back
#define pi 3.14159265358979323846
#define pp pop_back
#define pf pop_front
using kk = long double;
#define endl "\n"
#define rese(x,y) memset(x,y,sizeof(x))
#define f first
#define ul unsigned long
#define pii pair<ll,ll>
#define cc continue
#define ee end
#define ii insert
#define fr front
#define mod 1000000007
#define ss size
#define b begin
#define up upper_bound
#define pc pop_back()
//#define mp make_pair
//#define r reverse
#define bb back
#define maxu 1000000000
#define CHARS_TOTAL 256
#define INT_BITS 32
//typedef std::pair<std::string,std::string>pair;
const ll alpha=1e18;
/* For counting number of digits, directly do floor(log10(n)+1)*/
using namespace std;
ll gcd(ll a, ll b)
{
    // Everything divides 0
    if (a == 0)
       return b;
    if (b == 0)
       return a;
 
    // base case
    if (a == b)
        return a;
 
    // a is greater
    if (a > b)
        return gcd(a-b, b);
    return gcd(a, b-a);
}
ll largest(ll arr[], ll n)
{
    return *max_element(arr, arr+n);
}
// Function to return LCM of two numbers
 ll lcm(ll a, ll b)
 {
    return (a*b)/gcd(a, b);
 }
 
void sieve(bool primes[], ll x)
{
    primes[1] = false;
    for (ll i=2; i*i <= x; i++)
    {
        if (primes[i] == true)
        {
            for (ll j=2; j*i <= x; j++)
                primes[i*j] = false;
        }
    }
}
 
 
// Function to generate mersenne primes less
// than or equal to n
 
 
ll power(ll x, unsigned ll y, ll p)
{
    ll res = 1;      // Initialize result
 
    x = x % p;  // Update x if it is more than or
                // equal to p
 
    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;
 
        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}
class gfg
{
 public: ll sumDigits(ll no)
 {
   return no == 0 ? 0 : no%10 + sumDigits(no/10) ;
 }
};
 
 
bool isPerfectSquare(long double x)
{
  // Find floating poll value of
  // square root of x.
  long double sr = sqrt(x);
 
  // If square root is an lleger
  return ((sr - floor(sr)) == 0);
}
 
 
bool comp(ll a, ll b)
{
    return (a < b);
}
vector<ll>ve;
void divisors(ll n)
{
    // Note that this loop runs till square root
    for (ll i=1; i<=sqrt(n); i++)
    {
        if (n%i == 0)
        {
            // If divisors are equal, print only one
            if (n/i == i)
                ve.pb(i);
 
            else // Otherwise print both
            ve.pb(i);
            ve.pb(n/i);
        }
    }
}
bool isPrime(ll n) {
 
    if (n == 1) {
        return false;
    }
 
    ll i = 2;
 
    while (i*i <= n) {
 
        if (n % i == 0) {
             return false;
        }
        i += 1;
    }
    return true;
}
 
ll gcdofarray(vector<ll>&v, ll n)
{
    ll result = v[0];
    for (ll i = 1; i < n; i++)
        result = gcd(v[i], result);
    return result;
}
 
ll sumofdigits(ll n){
        ll sum=0;
        while(n>0){
            sum+=n%10;
            n/=10;
        }
        return sum;
}
bool powertwo(ll x){
  return x&& (!(x&(x-1)));
}
ll finduncommonsubsequence(string str,string s){
    if(!str.compare(s)){
        return 0;
    }
    return max(str.length(),s.length());
}
void reversec(string str)
{
   for (ll i=str.length()-1; i>=0; i--)
      cout << str[i];
}
 
string removeDuplicatesFromString(string str)
{
 
    // keeps track of visited characters
    ll counter = 0;
 
    ll i = 0;
    ll size = str.size();
 
    // gets character value
    ll x;
 
    // keeps track of length of resultant string
    ll length = 0;
 
    while (i < size) {
        x = str[i] - 97;
 
        // check if Xth bit of counter is unset
        if ((counter & (1 << x)) == 0) {
 
            str[length] = 'a' + x;
 
            // mark current character as visited
            counter = counter | (1 << x);
 
            length++;
        }
        i++;
    }
 
    return str.substr(0, length);
}
ll commDiv(ll a,ll b)
{
    // find gcd of a,b
    ll n = gcd(a, b);
 
    // Count divisors of n.
    ll result = 0;
    for (ll i=1; i<=sqrt(n); i++)
    {
        // if 'i' is factor of n
        if (n%i==0)
        {
            // check if divisors are equal
            if (n/i == i)
                result += 1;
            else
                result += 2;
        }
    }
    return result;
}
ll kash(ll a,ll b){
    return (a*b)/gcd(a,b);
}
ll maxi(ll a,ll b){
   return (a>b)?a:b;
}
ll mini(ll a,ll b){
   return (a<b)?a:b;
}
ll nCrModp(ll n, ll r, ll p)
{
    ll C[r+1];
    memset(C, 0, sizeof(C));
 
    C[0] = 1;
    for (ll i = 1; i <= n; i++)
    {
        for (ll j = min(i, r); j > 0; j--)
            C[j] = (C[j] + C[j-1])%p;
    }
    return C[r];
}
ll power(ll x,ll y,ll p) 
{ 
    ll res = 1;      // Initialize result 
  
    x = x % p;  // Update x if it is more than or  
                // equal to p 
  
    while (y > 0) 
    { 
        // If y is odd, multiply x with result 
        if (y & 1) 
            res = (res*x) % p; 
  
        // y must be even now 
        y = y>>1; // y = y/2 
        x = (x*x) % p;   
    } 
    return res; 
} 
void solve() {
    //input
    ll t=1;
   // cin>>t;
    while(t--){
       string str;
       cin>>str;
       ll i;
       if(str.length()<7){
          cout<<"no"<<endl;
          return;
       }
       else{
          //cout<<"qqqq";
          ll z=0;
          for(i=str.length();i>=0;i--){
           // cout<<str[i]<<endl;
             if(str[i]=='0'){
                z++;
             }
             if(z>=6 && str[i]=='1'){
                cout<<"yes"<<endl;
                return;
             }
          } 
      }
      cout<<"no"<<endl;
    }
}
int main()
{
    fio;
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif
    solve();
}