#include<bits/stdc++.h>
using namespace std;
// #include <boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;
#define fio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define ll long long int
#define ull unsigned long long int  // ranges from (0 - twice of long long int)
#define rep(i,a,n) for (ll i=a;i<n;i++)
#define per(i,a,n) for (ll i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define vll vector<ll>
#define mod 1000000007LL
#define llpair pair<ll,ll>
#define INF 1000000000000000000ll
#define np next_permutation
#define PI acos(-1)
#define deb(x) cout<<#x<<" "<<x<<endl;
//ALWAYS USE ll DATA TYPE FOR INTEGER(FASTER THAN INTEGER AS WELL AS SOMETIMES WITHOUT USE LONG UR ANSWER WILL NOT ACCEPTED) && DOUBLE FOR DECIMAL VALUE
template<typename T> // for removing front element from the vector
void pop_front(std::vector<T> &v)
{
    if (v.size() > 0) {
        v.erase(v.begin());
    }
}
template<typename R> // for removing back element from the vector or can directly
void pop_back(std::vector<R> &v) // use vec.pop_back() function...
{
    if (v.size() > 0) {
        v.erase(v.begin()+v.size()-1);
    }
}

bool isprime(ll n)  //IN  O(sqrt(n))
{
    if(n<=1) return false;
    for(ll i=2;i*i<=n;i++)
        if(n%i==0)
            return false;

    return true;
}

vector<ll> factors(ll n){    //IN  O(sqrt(n))

    vll v;
    for(ll i=1;i*i<=n;i++)
    {
        if(n%i==0)
        {
            v.pb(i);
            if((n/i)!=i)
            v.pb(n/i);
        }
    }
    return v;
}

ll power(ll a, ll n)  // using Binary Exponential in TC O(logn)
{                     // Self Written By </ME> :)
    ll res=1;
    while(n)
    {
        if(n%2) 
        res=res*a,n--;
        else
        a=a*a,n/=2;
    }
    return res;
}


/*
// ############# DISJOINT SET FUNCTIONS ##############

###################ABOUT FIND FUNCTION IN DISJOINT SET -> work always is to return the parent of the set nothing itn has to do
// In set you can't join one element to another element or linked any element to other element except
// the parent node, it means only parent Node Can Be Edditable In A SET
    
    
int find(ll n)
{
    if(parent[n]<0)
        return n;
    else
        return find(parent[n]); 
}

//############################### I LOVE UNION BY RANK ############## UMMMHHHHHHHH ###############
// If You are Only doing Union By Rank then there is no need to apply path compression baby
// If logic is simple that don't try to need the length of the tree make it as a logn by checking
// everytime the rank of element element during insertion

// ############### either do UNION BY RANK OR PATH COMPRESSION####################  
void uni(ll a,ll b)
{
    
    if(R[a]>R[b])
    {
        parent[a]+=parent[b];
        R[a]+=R[b];
        parent[b]=a;
    }
    else
    {
        parent[b]+=parent[a];
        R[b]+=R[a]; 
        parent[a]=b;
    }

    
}    
    
*/

/*   1.   Binary/Hexa/Octa to interger or decimal ->>>>>>  int d =stoi(s,nullptr,2); 

  
  	 2.	  Now Another is Decimal/Interger to Binary->>>>>  string k =bitset<32>(128).to_string();  
 */



int main() {
    auto start = chrono::high_resolution_clock::now();
    fio;
    ll t=1; 
    //cin>>t;
    while(t--)
    {
		ll n; cin>>n;
		int flag=0;
		while(n)
		{
			int m= n%10;
			if(m==7)
			{
				flag=1;
				break;
			}
			n=n/10;
		}
		
		if(flag)
		cout<<"Yes"<<"\n";
		else
		cout<<"No"<<"\n";
		
		
		
		
		
    }

    auto finish = chrono::high_resolution_clock::now();
    cerr << "Time elapsed: " << (chrono::duration<long double>(finish-start)).count() << "s\n";
    return 0;
        
}
