stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <iostream>

#include <algorithm>



using namespace std;

int main()

{

	int n,a[200010];

	long long sum[200010]={0};

	cin >> n;

	for(int i=0; i<n; i++){

		cin >> a[i];

	}

	sum[0] = a[0];

	for(int i=1; i<n; i++){

		sum[i] = sum[i-1] + a[i];

	}

	sort(sum,sum+n);

	long long ans=0,cnt=0;

	for(int i=0; i<n; i++){

		if(sum[i] == 0)

			cnt++;

	}

	ans += (cnt * (cnt + 1)) / 2;

	cnt = 0;

	int tmp = -2;

	for(int i=0; i<n-1; i++){

		if(sum[i] == sum[i+1]){

			if(sum[i] != 0){

				cnt++;

				tmp = i;

				if(i == n-2)

					ans += (cnt * (cnt + 1)) / 2;

			}

		}

		else if(tmp == i - 1){

			ans += (cnt * (cnt + 1)) / 2;

			cnt = 0;

		}

	}

	cout << ans << endl;

	

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.538272822565063x):
#include <iostream>

#include <algorithm>



using namespace std;

int main()

{

	int n;

	long long sum[200010], a;

	cin >> n;

	sum[0] = 0;

	for(int i=1; i<=n; i++){

		cin >> a;

		sum[i] = sum[i-1] + a;

	}

	sort(sum,sum+n+1);

	long long ans = 0;

    long long now = sum[0];

  	long long cnt = 1;

	for(int i=1; i<=n; i++){

		if(now == sum[i]){

			cnt++;

		}

		else{

			ans += (cnt * (cnt-1)) / 2;

			now = sum[i];

			cnt = 1;

		}

	}

	cout << ans + (cnt * (cnt-1)) / 2 << endl;

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<ll, ll> lpair;

const ll MOD = 1e9 + 7;

const ll INF = 1e18;

#define rep(i,m,n) for(ll i = (m); i < (n); i++)

#define rrep(i,m,n) for(ll i = (m); i >= (n); i--)

#define print(x) cout << (x) << endl;

#define print2(x,y) cout << (x) << " " << (y) << endl;

#define printa(x,n) for(ll i = 0; i < n; i++){ cout << (x[i]) << " ";} cout<<endl;

int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    ll N;

    ll A[200010];

    cin >> N;

    rep(i,0,N) cin >> A[i];

    ll sum[200010] = {};

    rep(i,0,N) sum[i+1] = sum[i] + A[i];

    ll ans = 0;

    map<ll,ll> mp;

    rep(i,0,N+1) mp[sum[i]]++;

    for(auto &e: mp){

        ans += e.second * (e.second-1) / 2;

    }

    print(ans);

    

}

// Faster C++ solution for the same problem (measured speedup: 2.618831965846915x):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<ll, ll> lpair;

const ll MOD = 1e9 + 7;

const ll INF = 1e18;

#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )

#define rep(i,n) REP(i,0,n)

#define rREP(i,m,n) for(ll i = (m); i >= (n); i--)

#define print(x) cout << (x) << endl;

#define printa(x,n) for(ll i = 0; i < n; i++){ cout << (x[i]) << " ";} cout<<endl;

int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    

    int n;cin>>n;

    ll ary[n];

    rep(i,n) cin >> ary[i];

    ll ruisekiwa[n+1];

    ruisekiwa[0] = 0;

    map<ll, ll> mp;

    mp[0] = 1;

    rep(i,n)

    {

        ruisekiwa[i+1] = ruisekiwa[i]+ary[i];

        if (mp.find(ruisekiwa[i+1])==mp.end())

        {

            mp[ruisekiwa[i+1]] = 1;

        }

        else

        {

            mp[ruisekiwa[i+1]]++;

        }

    }

    ll ans = 0;

    for (auto itr = mp.begin(); itr != mp.end(); ++itr)

    {

        ans += itr->second * (itr->second-1) / 2;

        // std::cout << "key = " << itr->first           // キーを表示

        //                 << ", val = " << itr->second << "\n";    // 値を表示

    }

    cout << ans << endl;



}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn=2e5+7;

int a[maxn],cnt[maxn]={0};

ll pre[maxn]={0},jie[maxn];

void init()

{

    jie[0]=0;

    jie[1]=1;

    for(int i=2;i<maxn;++i)

        jie[i]=i+jie[i-1];

}

int main()

{

    ios::sync_with_stdio(false);

    //freopen("in.txt","r",stdin);

    init();

    int n;

    cin>>n;

    ll ans=0;

    set<int> st;

    map<ll,int> mp;

    for(int i=1;i<=n;++i){

        cin>>a[i];

        pre[i]=a[i]+pre[i-1];

        mp[pre[i]]++;

    }

    map<ll,int>::iterator it=mp.begin();

    for(;it!=mp.end();++it){

        if(it->first==0)

            ans+=jie[it->second];

        else

            ans+=jie[it->second-1];

    }

    cout<<ans<<endl;

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 2.6609683614854553x):
/*

 * Author : Andrew J

*/

#include <bits/stdc++.h>

using namespace std;

#define rall(x) x.rbegin() , x.rend()

#define all(x) x.begin() , x.end()

#define fi first

#define se second

#define pb push_back

using ll = long long;

using ii = pair <ll , ll>;

void in(ll &x);

const ll N = 2e5 + 10;

#define singleCase

// #define multipleCase

ll n,a[N],ps[N];

map <ll , ll> freq;



void work() {

   in(n);

   for (ll i = 1 ; i <= n ; i++) {

      in(a[i]);

      ps[i] = ps[i - 1] + a[i];

   }

   for (ll i = 0 ; i <= n ; i++) {

      freq[ps[i]]++;

   }

   ll sol = 0;

   for (ii x : freq) {

      sol += (x.se * (x.se - 1)) / 2;

   }

   printf("%lld\n" , sol);

   return;

}



int main() {

   #ifdef multipleCase

      ll nQ; in(nQ);

      while (nQ--)

         work();

   #endif

   #ifdef singleCase

      work();

   #endif

   return 0;

}



void in(ll &x) {

	bool neg = false;

	register ll c;

	x = 0;

	c = getchar();

	if(c == '-') {

		neg = true;

		c = getchar();

	}

	for (; c > 47 && c < 58; c = getchar())

	  x = (x << 1) + (x << 3) + c - 48;

	if (neg) x *= -1;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <map>

typedef long long ll;



std::map<ll, ll> mp;



int main()

{

	ll n;

	std::vector<ll> arr(200005);



	ll ans = 0;



	std::cin >> n;

	for (ll i = 1; i <= n; i++) {

		std::cin >> arr[i];

	}



	mp[0] = 1;

	for (ll i = 1; i <= n; i++) {

		arr[i] = arr[i] + arr[i - 1];



		ans = ans + mp[arr[i]];

		mp[arr[i]]++;

	}



	std::cout << ans << std::endl;



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.5291426104302523x):
#include <iostream>

#include <map>

using namespace std;

typedef long long ll;



int main()

{

    ll n;

    ll a[2 * 100005];

    ll ans = 0;

    map<ll, ll> mp;

    mp[0] = 1;



    cin >> n;

    for (int i = 1; i <= n; i++) {

        cin >> a[i];

        a[i] += a[i - 1];



        ans += mp[a[i]];



        mp[a[i]]++;

    }



    cout << ans << endl;



    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <map>

using namespace std;



map<long long, long long> mp;



int main()

{

	long long n;

	vector<long long> vec(2 * 100005);

	long long ans = 0;



	cin >> n;

	for (long long i = 1; i <= n; i++) {

		cin >> vec[i];

	}



	mp[0] = 1;

	for (long long i = 1; i <= n; i++) {

		vec[i] += vec[i - 1];



		ans = ans + mp[vec[i]];

		mp[vec[i]]++;

	}



	cout << ans << endl;



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.529193904479811x):
#include <iostream>

#include <map>

using namespace std;

typedef long long ll;



int main()

{

    ll n;

    ll a[2 * 100005];

    ll ans = 0;

    map<ll, ll> mp;

    mp[0] = 1;



    cin >> n;

    for (int i = 1; i <= n; i++) {

        cin >> a[i];

        a[i] += a[i - 1];



        ans += mp[a[i]];



        mp[a[i]]++;

    }



    cout << ans << endl;



    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <map>

typedef long long ll;



std::map<ll, ll> mp;



int main()

{

	ll n;

	std::vector<ll> arr(200005);



	ll ans = 0;



	std::cin >> n;

	for (ll i = 1; i <= n; i++) {

		std::cin >> arr[i];

	}



	mp[0] = 1;

	for (ll i = 1; i <= n; i++) {

		arr[i] = arr[i] + arr[i - 1];



		ans = ans + mp[arr[i]];

		mp[arr[i]]++;

	}



	std::cout << ans << std::endl;



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.622200139377173x):
#include <iostream>

#include <set>

#include <map>

using namespace std; // 575;



map<long long, long long> ms; // ms... Windowsっぽくね？

long long n;

long long a[200005];

long long ans;



int main()

{

    cin >> n;

    for (int i = 1; i <= n; i++) {

        cin >> a[i];

    }



    ms[0] = 1;

    for (int i = 1; i <= n; i++) {

        a[i] += a[i - 1];



        ans += ms[a[i]];

        ms[a[i]] += 1;

    }



    cout << ans << endl;

    

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <map>

using namespace std;



map<long long, long long> mp;



int main()

{

	long long n;

	vector<long long> vec(2 * 100005);

	long long ans = 0;



	cin >> n;

	for (long long i = 1; i <= n; i++) {

		cin >> vec[i];

	}



	mp[0] = 1;

	for (long long i = 1; i <= n; i++) {

		vec[i] += vec[i - 1];



		ans = ans + mp[vec[i]];

		mp[vec[i]]++;

	}



	cout << ans << endl;



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.6222533207451773x):
#include <iostream>

#include <set>

#include <map>

using namespace std; // 575;



map<long long, long long> ms; // ms... Windowsっぽくね？

long long n;

long long a[200005];

long long ans;



int main()

{

    cin >> n;

    for (int i = 1; i <= n; i++) {

        cin >> a[i];

    }



    ms[0] = 1;

    for (int i = 1; i <= n; i++) {

        a[i] += a[i - 1];



        ans += ms[a[i]];

        ms[a[i]] += 1;

    }



    cout << ans << endl;

    

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <map>

typedef long long ll;



std::map<ll, ll> mp;



int main()

{

	ll n;

	std::vector<ll> arr(200005);



	ll ans = 0;



	std::cin >> n;

	for (ll i = 1; i <= n; i++) {

		std::cin >> arr[i];

	}



	mp[0] = 1;

	for (ll i = 1; i <= n; i++) {

		arr[i] = arr[i] + arr[i - 1];



		ans = ans + mp[arr[i]];

		mp[arr[i]]++;

	}



	std::cout << ans << std::endl;



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.5954978608725674x):
#define _overload(_1, _2, _3, _4, name, ...) name

#define _rep1(Itr, N) _rep3(Itr, 0, N, 1)

#define _rep2(Itr, a, b) _rep3(Itr, a, b, 1)

#define _rep3(Itr, a, b, step) for (llong (Itr) = a; (Itr) < b; (Itr) += step)

#define repeat(...) _overload(__VA_ARGS__, _rep3, _rep2, _rep1)(__VA_ARGS__)



#include <iostream>

#include <map>

#include <vector>

using namespace std;

using llong = long long;





int main() {

    int n;

    vector<llong> a;

    cin >> n;

    a.resize(n);

    for (auto &vs:a) cin >> vs;



    map<llong, llong> mp;

    mp[0] = 1;



    llong ans = 0;

    llong s = 0;

    for (auto vs:a) {

        s += vs;

        ans += mp[s];

        mp[s]++;

    }



    cout << ans << endl;



    return 0;

};
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <map>

using namespace std;



map<long long, long long> mp;



int main()

{

	long long n;

	vector<long long> vec(2 * 100005);

	long long ans = 0;



	cin >> n;

	for (long long i = 1; i <= n; i++) {

		cin >> vec[i];

	}



	mp[0] = 1;

	for (long long i = 1; i <= n; i++) {

		vec[i] += vec[i - 1];



		ans = ans + mp[vec[i]];

		mp[vec[i]]++;

	}



	cout << ans << endl;



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.595550500686295x):
#define _overload(_1, _2, _3, _4, name, ...) name

#define _rep1(Itr, N) _rep3(Itr, 0, N, 1)

#define _rep2(Itr, a, b) _rep3(Itr, a, b, 1)

#define _rep3(Itr, a, b, step) for (llong (Itr) = a; (Itr) < b; (Itr) += step)

#define repeat(...) _overload(__VA_ARGS__, _rep3, _rep2, _rep1)(__VA_ARGS__)



#include <iostream>

#include <map>

#include <vector>

using namespace std;

using llong = long long;





int main() {

    int n;

    vector<llong> a;

    cin >> n;

    a.resize(n);

    for (auto &vs:a) cin >> vs;



    map<llong, llong> mp;

    mp[0] = 1;



    llong ans = 0;

    llong s = 0;

    for (auto vs:a) {

        s += vs;

        ans += mp[s];

        mp[s]++;

    }



    cout << ans << endl;



    return 0;

};
// Slower C++ solution:
#include <iostream>

#include <fstream>

#include <set>

#include <map>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <functional>

#include <algorithm>

#include <climits>

#include <cmath>

#include <iomanip>

using namespace std;

#define ll long long int

#define rep(i,n) for( int i = 0; i < n; i++ )

#define rrep(i,n) for( int i = n; i >= 0; i-- )

#define REP(i,s,t) for( int i = s; i <= t; i++ )

#define RREP(i,s,t) for( int i = s; i >= t; i-- )

#define dump(x)  cerr << #x << " = " << (x) << endl;

#define INF 2000000000

#define mod 1000000007

#define INF2 1000000000000000000

#define int long long



signed main(void)

{

    cin.tie(0);

    ios::sync_with_stdio(false);

    int N; cin >> N;

    int a[200010];

    rep(i, N) cin >> a[i];

    int sum[200010] = {};

    rep(i, N) sum[i + 1] = sum[i] + a[i];

    map<int, int> mp;

    rep(i, N + 1) mp[sum[i]]++;

    int ans = 0;

    int num = 0;

    rep(i, N) {

        ans += mp[num] - 1;

        mp[sum[i]]--;

        num += a[i];

    }

    cout << ans << endl;



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.645232925857978x):
#include <iostream>

#include <fstream>

#include <set>

#include <map>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <functional>

#include <algorithm>

#include <climits>

#include <cmath>

#include <iomanip>

using namespace std;

#define ll long long int

#define rep(i,n) for( int i = 0; i < n; i++ )

#define rrep(i,n) for( int i = n; i >= 0; i-- )

#define REP(i,s,t) for( int i = s; i <= t; i++ )

#define RREP(i,s,t) for( int i = s; i >= t; i-- )

#define dump(x)  cerr << #x << " = " << (x) << endl;

#define INF 2000000000

#define mod 1000000007

#define INF2 1000000000000000000

#define int long long

int a[200010];

int sum[200010];

map<int, int> mp;

signed main(void)

{

    cin.tie(0);

    ios::sync_with_stdio(false);

    int n; cin >> n;

    

    rep(i, n) cin >> a[i];

    rep(i, n) sum[i + 1] = sum[i] + a[i];

    rep(i, n + 1) {

        mp[sum[i]]++;

    }

    int ans = 0;

    rep(i, n) {

        mp[sum[i]]--;

        ans += mp[sum[i]];

    }

    cout << ans << endl;



    return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main ()

{

int k,x;

cin>>k>>x;

if (k*500 >= x) cout << "Yes";

else cout << "No";

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.312916447748831x):
#include<stdio.h>



int main(){

int a,b;

scanf("%d%d", &a,&b);

if(a*500>=b)puts("Yes");

else puts("No");

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main ()

{

int k,x;

cin>>k>>x;

if (k*500 >= x) cout << "Yes";

else cout << "No";

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.298001057645698x):
#include <stdio.h>



int main (){

	

	int a,b,n=0;

	

	scanf("%d %d",&a,&b);

	

	n=a*500;

	

	if(n>=b){

		printf("Yes\n");

	}else printf("No\n");





return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main ()

{

int k,x;

cin>>k>>x;

if (k*500 >= x) cout << "Yes";

else cout << "No";

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.296855660370136x):
#include<stdio.h>



int main(){

	

	int k;

	k>=1 && k<=100;

	int x;

	x>=1 && x<=100000;

	scanf("%d %d",&k,&x);

	

	if(k * 500>=x){

		printf("Yes");

	}

	else if(k * 500<x){

		printf("No");

	}

	

	

	

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main ()

{

int k,x;

cin>>k>>x;

if (k*500 >= x) cout << "Yes";

else cout << "No";

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.299999485969053x):
#include <stdio.h>

int main(){

int K;

int X;



scanf("%d",&K);

scanf("%d",&X);

	

if(K*500>=X){

	printf("Yes\n");

}	

else {

	printf("No\n");

}	

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main ()

{

int k,x;

cin>>k>>x;

if (k*500 >= x) cout << "Yes";

else cout << "No";

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.296855660370136x):
#include <stdio.h>

int main()

{

	int K,X;

	int i;

	scanf("%d %d",&K,&X);

	i=K*500;

	if(i>=X)

	{

		printf("Yes");

	}

	else

	{

		printf("No");

	}

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main ()

{

int k,x;

cin>>k>>x;

if (k*500 >= x) cout << "Yes";

else cout << "No";

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.299189813422959x):
#include<stdio.h>

int main(){

  int K;

  int X;

  scanf("%d", &K);

  scanf("%d", &X);

     

  if(K*500>=X){

    printf("Yes");

  }else{

    printf("No");

     }

  return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main ()

{

int k,x;

cin>>k>>x;

if (k*500 >= x) cout << "Yes";

else cout << "No";

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.298001057645698x):
#include <stdio.h>

int main () 

{

int a, b;

scanf("%d %d", &a, &b) ;

if ( (a*500) >= b) {

printf("Yes\n") ;

}

else {

printf("No\n") ;

}

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main ()

{

int k,x;

cin>>k>>x;

if (k*500 >= x) cout << "Yes";

else cout << "No";

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.296855660370136x):
#include<stdio.h>

int main()

{

	int K,X;

	scanf("%d %d", &K, &X);

	

	if(X <= K*500){

		printf("Yes");

	}

	else{

		printf("No");

	}

	

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

main()

{

int K,X,N;

cin>>K>>X;

K<=500;

K=500*K;

if(K>=X)

    cout<<"Yes";

else

    cout<<"No";

}




// Faster C++ solution for the same problem (measured speedup: 5.297944363805731x):
#include<stdio.h>

int main(){

	int k, x, m;

	scanf("%d %d", &k, &x);

	k>=1;

	k<=100;

	x>=1;

	x<=100000;

	

	m = k*500;

	if(m>x-1){

		printf("Yes\n");

	}

	else{

		printf("No\n");

	}

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int main() 

{

	int k,x;

	cin>>k>>x;

	k=k*500;

	if(k>=x)

	printf("Yes\n");

	else

	printf("No\n");

}

// Faster C++ solution for the same problem (measured speedup: 5.285814157821595x):
#include<stdio.h>

int main(){

	int k, x, m;

	scanf("%d %d", &k, &x);

	k>=1;

	k<=100;

	x>=1;

	x<=100000;

	

	m = k*500;

	if(m>x-1){

		printf("Yes\n");

	}

	else{

		printf("No\n");

	}

	

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

main()

{

int K,X,N;

cin>>K>>X;

K<=500;

K=500*K;

if(K>=X)

    cout<<"Yes";

else

    cout<<"No";

}




// Faster C++ solution for the same problem (measured speedup: 5.299133106862133x):
#include <stdio.h>

int main()

{

    int a ;

    scanf("%d",&a);

    

    int b;

    scanf("%d",&b);

    

    int c = a*500;

    

    if( c>=b){

        printf("Yes");



    }

    

    else{

        printf("No");

    }



    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int main() 

{

	int k,x;

	cin>>k>>x;

	k=k*500;

	if(k>=x)

	printf("Yes\n");

	else

	printf("No\n");

}

// Faster C++ solution for the same problem (measured speedup: 5.287000179124587x):
#include <stdio.h>

int main()

{

    int a ;

    scanf("%d",&a);

    

    int b;

    scanf("%d",&b);

    

    int c = a*500;

    

    if( c>=b){

        printf("Yes");



    }

    

    else{

        printf("No");

    }



    return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

main()

{

int K,X,N;

cin>>K>>X;

K<=500;

K=500*K;

if(K>=X)

    cout<<"Yes";

else

    cout<<"No";

}




// Faster C++ solution for the same problem (measured speedup: 5.2967989787870495x):
#include <stdio.h>

 

int main()

{

	int k, x;

	scanf("%d %d", &k, &x);

	

	if(k*500>=x)

{

	printf("Yes");

}

	else

{

	printf("No");

}

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int main() 

{

	int k,x;

	cin>>k>>x;

	k=k*500;

	if(k>=x)

	printf("Yes\n");

	else

	printf("No\n");

}

// Faster C++ solution for the same problem (measured speedup: 5.284671395283494x):
#include <stdio.h>

 

int main()

{

	int k, x;

	scanf("%d %d", &k, &x);

	

	if(k*500>=x)

{

	printf("Yes");

}

	else

{

	printf("No");

}

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

main()

{

int K,X,N;

cin>>K>>X;

K<=500;

K=500*K;

if(K>=X)

    cout<<"Yes";

else

    cout<<"No";

}




// Faster C++ solution for the same problem (measured speedup: 5.2967989787870495x):
#include <stdio.h>



int main()

{

	int a, b;

	scanf("%d %d", &a, &b);

	

	if(a*500>=b)

{

	printf("Yes");

}

	else

{

	printf("No");

}



	return 0;





}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int main() 

{

	int k,x;

	cin>>k>>x;

	k=k*500;

	if(k>=x)

	printf("Yes\n");

	else

	printf("No\n");

}

// Faster C++ solution for the same problem (measured speedup: 5.284671395283494x):
#include <stdio.h>



int main()

{

	int a, b;

	scanf("%d %d", &a, &b);

	

	if(a*500>=b)

{

	printf("Yes");

}

	else

{

	printf("No");

}



	return 0;





}
// Slower C++ solution:
#include<iostream>

using namespace std;

main()

{

int K,X,N;

cin>>K>>X;

K<=500;

K=500*K;

if(K>=X)

    cout<<"Yes";

else

    cout<<"No";

}




// Faster C++ solution for the same problem (measured speedup: 5.2977787572660775x):
#include <stdio.h>



int main() {

	int K, X;

	scanf("%d %d", &K, &X);

	

	if (K * 500 < X ){

		printf("No\n");

	}else{

		printf("Yes\n");

	} 

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int main() 

{

	int k,x;

	cin>>k>>x;

	k=k*500;

	if(k>=x)

	printf("Yes\n");

	else

	printf("No\n");

}

// Faster C++ solution for the same problem (measured speedup: 5.285648930455693x):
#include <stdio.h>



int main() {

	int K, X;

	scanf("%d %d", &K, &X);

	

	if (K * 500 < X ){

		printf("No\n");

	}else{

		printf("Yes\n");

	} 

	

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main()

{

    int K , X , Y, into;

    cin >> Y >> X;

    K = 500;

    into = K*Y;

    if (into >= X) cout << "Yes" << endl ;

    else cout << "No" << endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.31216907869746x):
#include <stdio.h>



int main()

{

    int num, max;

    scanf("%d %d", &num, &max);



    num *= 500;

    num >= max ? printf("Yes\n") : printf("No\n"); 



    return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;

    int c=a*500;



    if(c>=b)

        cout<< "Yes"<<endl;

    if(c<b)

        cout<< "No"<<endl;

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.312652377017058x):
#include <stdio.h>



int main()

{

    int num, max;

    scanf("%d %d", &num, &max);



    num *= 500;

    num >= max ? printf("Yes\n") : printf("No\n"); 



    return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main()

{

    int K , X , Y, into;

    cin >> Y >> X;

    K = 500;

    into = K*Y;

    if (into >= X) cout << "Yes" << endl ;

    else cout << "No" << endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.312269670540374x):
#include <stdio.h>



int main (){

	

	int k,x;

	int z = 500;

	scanf ("%d %d", &k, &x);

	if (k*z >= x){

		printf ("Yes\n");

	}

	else if (k*z <= x){

		printf ("No\n");

	}

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;

    int c=a*500;



    if(c>=b)

        cout<< "Yes"<<endl;

    if(c<b)

        cout<< "No"<<endl;

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.312752978011765x):
#include <stdio.h>



int main (){

	

	int k,x;

	int z = 500;

	scanf ("%d %d", &k, &x);

	if (k*z >= x){

		printf ("Yes\n");

	}

	else if (k*z <= x){

		printf ("No\n");

	}

	return 0;

}