stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
// Author: Amey Bhavsar

// IDE: Geany/Ubuntu

// Platform: *



#include<bits/stdc++.h>

using namespace std;



typedef long long ll;



#define rep(i,a,b) for(auto i=a;i<b;i++)

#define repD(i,a,b) for(auto i=a;i>=b;i--)

#define pb push_back

#define mp make_pair

#define ff first

#define ss second



// to be used with algorithms that processes a container Eg: find(all(c),42)

#define all(x) (x).begin(), (x).end() //Forward traversal

#define rall(x) (x).rbegin, (x).rend() //reverse traversal

// traversal function to avoid long template definition

#define tr(c,i) for(__typeof__((c)).begin() i = (c).begin(); i != (c).end(); i++)

//find version works for all containers. This is present in std namespace.

#define cpresent(c,x) (find(all(c),x) != (c).end())

// ll fe (ll x, ll y) {

	// ll ans = 1;

	// while (y>0) {

		// if (y&1) {

			// ans = (x*ans) % MOD;

		// }

		// y /= 2;

		// x = (x*x) % MOD;

	// }

	// return (ans % MOD);

// }



// ll modmul(ll a, ll b) {

    // return ((a%MOD) * (b%MOD)) % MOD;

// }



// ll modadd(ll a , ll b){

    // return((a%MOD)+(b%MOD)+MOD)%MOD;

// }



// ll modsub(ll a , ll b){

    // return((a%MOD) - (b%MOD) + MOD)%MOD;

// }

#define MOD 1000000007

// int n;

// vector<int> a;

// void solution() {

	// cin >> n;

	// a.resize(n);

	// for (auto& e:a) {

		// cin >> e;

	// }

// }



int main() {

	ios_base::sync_with_stdio(false);cin.tie(NULL);

	int a,b;

	cin >> a >> b;

	if (a >= 10) {

		cout << b;

	} else {

		cout << 100*(10-a) + b;

	}

	return 0;

}


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



int main()

{

	int N, R;

	scanf("%d%d",&N,&R);

	if(R>4111)

	{

		printf("second value must between 0-4111");

	}

	else if(N>=10)

	{

		printf("%d", R);

	}

	else

	{

		printf("%d", R+100*(10-N));

	}

	return 0;

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

using namespace std;



int n, r;



int main (){

    cin>>n>>r;

    if (n<10){

        cout<<r+100*(10-n);

    }else {

        cout<<r;

    }



}

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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

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

using namespace std;



int N, R;



int main () {

	cin >> N >> R;

	if (N<10){

		cout << R + (100*(10-N));

	} else {

		cout << R;

	}

}


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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

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

#include <iostream>

using namespace std;



int N,R, inner;

int main(){

	cin >> N >> R;

	if (N<10){

		inner = R+ 100*(10-N);	

		cout << inner;

	}else {

		cout << R;

	}

}


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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

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

using namespace std;



int N, R;



int main () {

    cin >> N >> R;

    if (N >= 10) {

        cout << R << endl;

    } else {

       cout << R + 100*(10-N) << endl;

    }

}

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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

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

using namespace std;



int N, R;



int main() {

    cin >> N >> R;

    if (N >= 10)

        cout << R << endl;

        else { 

            cout << R + 100 *(10-N) << endl;

        }



}

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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

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

using namespace std;



int N,R;

int main(){

    cin>>N>>R;

    if(N>=10)

    cout<<R<<endl;

    else

    cout<<R+100*(10-N)<<endl;

}

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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

}
// Slower C++ solution:


#include <bits/stdc++.h>

#include<algorithm>

#include<cstring>

#include<cmath>

#include<cstdlib>

#include<string.h>

using namespace std;

#define pb push_back

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

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

#define per(i,n,v) for(i=n;i>v;i--)

#define ff first 

#define ss second 

#define pp pair<ll,ll>

#define ll  long long

#define endl '\n'

void solve()

{

  ll n, a,m=0,b=1, c,k=0, i, j,l=1e9+7;

  string s, r, y;

  cin>>n>>a;

  if(n>=10) cout<<a;

  else

  cout<<a+(100*(10-n));

}

int main()

{

 ios_base::sync_with_stdio(false);

  cin. tie(0);cout. tie(0);

    ll t=1;

   //cin>>t;

    while(t--)

    {

      solve();

    }

    return 0;

}

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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

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

using namespace std;

int n,r,ans;

int main()

{

    scanf("%d%d",&n,&r);

    if(n<10){

        ans=r+100*(10-n);

        printf("%d",ans);

    }else{

        ans=r;

        printf("%d",ans);

    }

    return 0;

}


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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

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



using namespace std;



int main(){

    int n, r;

    cin>>n>>r;



    if(n<10){

        cout<<r+100*(10-n);

    }else{

        cout<<r;

    }



    return 0;

}


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



int main() {

  int n, r;

  scanf("%d %d", &n, &r);

  

  if(n < 10) printf( "%d\n", r + (100 * (10 - n)) );

  else printf("%d\n", r);

  return 0;

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

using namespace std;



int n, r;



int main (){

    cin>>n>>r;

    if (n<10){

        cout<<r+100*(10-n);

    }else {

        cout<<r;

    }



}

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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

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

using namespace std;



int N, R;



int main () {

	cin >> N >> R;

	if (N<10){

		cout << R + (100*(10-N));

	} else {

		cout << R;

	}

}


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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

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

#include <iostream>

using namespace std;



int N,R, inner;

int main(){

	cin >> N >> R;

	if (N<10){

		inner = R+ 100*(10-N);	

		cout << inner;

	}else {

		cout << R;

	}

}


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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

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

using namespace std;



int N, R;



int main () {

    cin >> N >> R;

    if (N >= 10) {

        cout << R << endl;

    } else {

       cout << R + 100*(10-N) << endl;

    }

}

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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

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

using namespace std;



int N, R;



int main() {

    cin >> N >> R;

    if (N >= 10)

        cout << R << endl;

        else { 

            cout << R + 100 *(10-N) << endl;

        }



}

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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

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

using namespace std;



int N,R;

int main(){

    cin>>N>>R;

    if(N>=10)

    cout<<R<<endl;

    else

    cout<<R+100*(10-N)<<endl;

}

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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

}
// Slower C++ solution:


#include <bits/stdc++.h>

#include<algorithm>

#include<cstring>

#include<cmath>

#include<cstdlib>

#include<string.h>

using namespace std;

#define pb push_back

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

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

#define per(i,n,v) for(i=n;i>v;i--)

#define ff first 

#define ss second 

#define pp pair<ll,ll>

#define ll  long long

#define endl '\n'

void solve()

{

  ll n, a,m=0,b=1, c,k=0, i, j,l=1e9+7;

  string s, r, y;

  cin>>n>>a;

  if(n>=10) cout<<a;

  else

  cout<<a+(100*(10-n));

}

int main()

{

 ios_base::sync_with_stdio(false);

  cin. tie(0);cout. tie(0);

    ll t=1;

   //cin>>t;

    while(t--)

    {

      solve();

    }

    return 0;

}

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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

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

using namespace std;

int n,r,ans;

int main()

{

    scanf("%d%d",&n,&r);

    if(n<10){

        ans=r+100*(10-n);

        printf("%d",ans);

    }else{

        ans=r;

        printf("%d",ans);

    }

    return 0;

}


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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

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



using namespace std;



int main(){

    int n, r;

    cin>>n>>r;



    if(n<10){

        cout<<r+100*(10-n);

    }else{

        cout<<r;

    }



    return 0;

}


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

int main()

{

	int a,b;

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

	if(a<10)

	printf("%d\n",b+(100*(10-a)));

	else 

	printf("%d\n",b);

	

	return 0;

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

using namespace std;



int n, r;



int main (){

    cin>>n>>r;

    if (n<10){

        cout<<r+100*(10-n);

    }else {

        cout<<r;

    }



}

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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

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

using namespace std;



int N, R;



int main () {

	cin >> N >> R;

	if (N<10){

		cout << R + (100*(10-N));

	} else {

		cout << R;

	}

}


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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

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

#include <iostream>

using namespace std;



int N,R, inner;

int main(){

	cin >> N >> R;

	if (N<10){

		inner = R+ 100*(10-N);	

		cout << inner;

	}else {

		cout << R;

	}

}


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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

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

using namespace std;



int N, R;



int main () {

    cin >> N >> R;

    if (N >= 10) {

        cout << R << endl;

    } else {

       cout << R + 100*(10-N) << endl;

    }

}

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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

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

using namespace std;



int N, R;



int main() {

    cin >> N >> R;

    if (N >= 10)

        cout << R << endl;

        else { 

            cout << R + 100 *(10-N) << endl;

        }



}

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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

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

using namespace std;



int N,R;

int main(){

    cin>>N>>R;

    if(N>=10)

    cout<<R<<endl;

    else

    cout<<R+100*(10-N)<<endl;

}

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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

}
// Slower C++ solution:


#include <bits/stdc++.h>

#include<algorithm>

#include<cstring>

#include<cmath>

#include<cstdlib>

#include<string.h>

using namespace std;

#define pb push_back

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

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

#define per(i,n,v) for(i=n;i>v;i--)

#define ff first 

#define ss second 

#define pp pair<ll,ll>

#define ll  long long

#define endl '\n'

void solve()

{

  ll n, a,m=0,b=1, c,k=0, i, j,l=1e9+7;

  string s, r, y;

  cin>>n>>a;

  if(n>=10) cout<<a;

  else

  cout<<a+(100*(10-n));

}

int main()

{

 ios_base::sync_with_stdio(false);

  cin. tie(0);cout. tie(0);

    ll t=1;

   //cin>>t;

    while(t--)

    {

      solve();

    }

    return 0;

}

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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

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

using namespace std;

int n,r,ans;

int main()

{

    scanf("%d%d",&n,&r);

    if(n<10){

        ans=r+100*(10-n);

        printf("%d",ans);

    }else{

        ans=r;

        printf("%d",ans);

    }

    return 0;

}


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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

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



using namespace std;



int main(){

    int n, r;

    cin>>n>>r;



    if(n<10){

        cout<<r+100*(10-n);

    }else{

        cout<<r;

    }



    return 0;

}


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

int main()

{

	int N,R,A;

	scanf("%d %d", &N, &R);

	A =100*(10-N);

	if(N>=10){

		printf("%d", R);

	}

	else{

		printf("%d", R + A);

	}

return 0;

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

using namespace std;



int n, r;



int main (){

    cin>>n>>r;

    if (n<10){

        cout<<r+100*(10-n);

    }else {

        cout<<r;

    }



}

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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

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

using namespace std;



int N, R;



int main () {

	cin >> N >> R;

	if (N<10){

		cout << R + (100*(10-N));

	} else {

		cout << R;

	}

}


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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

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

#include <iostream>

using namespace std;



int N,R, inner;

int main(){

	cin >> N >> R;

	if (N<10){

		inner = R+ 100*(10-N);	

		cout << inner;

	}else {

		cout << R;

	}

}


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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

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

using namespace std;



int N, R;



int main () {

    cin >> N >> R;

    if (N >= 10) {

        cout << R << endl;

    } else {

       cout << R + 100*(10-N) << endl;

    }

}

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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

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

using namespace std;



int N, R;



int main() {

    cin >> N >> R;

    if (N >= 10)

        cout << R << endl;

        else { 

            cout << R + 100 *(10-N) << endl;

        }



}

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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

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

using namespace std;



int N,R;

int main(){

    cin>>N>>R;

    if(N>=10)

    cout<<R<<endl;

    else

    cout<<R+100*(10-N)<<endl;

}

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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

}
// Slower C++ solution:


#include <bits/stdc++.h>

#include<algorithm>

#include<cstring>

#include<cmath>

#include<cstdlib>

#include<string.h>

using namespace std;

#define pb push_back

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

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

#define per(i,n,v) for(i=n;i>v;i--)

#define ff first 

#define ss second 

#define pp pair<ll,ll>

#define ll  long long

#define endl '\n'

void solve()

{

  ll n, a,m=0,b=1, c,k=0, i, j,l=1e9+7;

  string s, r, y;

  cin>>n>>a;

  if(n>=10) cout<<a;

  else

  cout<<a+(100*(10-n));

}

int main()

{

 ios_base::sync_with_stdio(false);

  cin. tie(0);cout. tie(0);

    ll t=1;

   //cin>>t;

    while(t--)

    {

      solve();

    }

    return 0;

}

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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

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

using namespace std;

int n,r,ans;

int main()

{

    scanf("%d%d",&n,&r);

    if(n<10){

        ans=r+100*(10-n);

        printf("%d",ans);

    }else{

        ans=r;

        printf("%d",ans);

    }

    return 0;

}


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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

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



using namespace std;



int main(){

    int n, r;

    cin>>n>>r;



    if(n<10){

        cout<<r+100*(10-n);

    }else{

        cout<<r;

    }



    return 0;

}


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



int main()

{

	int N, R;

	scanf ("%d %d", &N, &R);

	

	if (N < 10)

	{

		printf ("%d", R + (100*(10 - N)));

	}

	else

	{

		printf ("%d", R);

	}

	

	return 0;

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

using namespace std;

int main()

{

	int n,r;

	cin>>n>>r;

	int m;

	if(n<10)

	{

		m=r+100*(10-n);

	}

	else{

		m=r;

	}

	cout<<m<<endl;

	return 0;

}

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

#include <string.h>



int main()

{

   int innerRating, displayRating, numContest;



   scanf("%d %d", &numContest, &displayRating);



   if (numContest >= 10)

   {

       printf("%d", displayRating);

   } else

   {

       innerRating = displayRating + (100*(10 - numContest));

       printf("%d", innerRating);

   }

    



    return 0;

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;

    if(a<10)

    {

        a=(100*(10-a));

        b+=a;

        cout<<b<<endl;

    }

    else

    {

        cout<<b<<endl;

    }

    return 0;

}


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

#include <string.h>



int main()

{

   int innerRating, displayRating, numContest;



   scanf("%d %d", &numContest, &displayRating);



   if (numContest >= 10)

   {

       printf("%d", displayRating);

   } else

   {

       innerRating = displayRating + (100*(10 - numContest));

       printf("%d", innerRating);

   }

    



    return 0;

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

using namespace std;







int main()

{

int n,r;

cin >> n >> r;

if (n >= 10){

    cout << r;

}

else {

   int  x= r+(100*(10-n));

    cout << x;

}

}




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

#include <string.h>



int main()

{

   int innerRating, displayRating, numContest;



   scanf("%d %d", &numContest, &displayRating);



   if (numContest >= 10)

   {

       printf("%d", displayRating);

   } else

   {

       innerRating = displayRating + (100*(10 - numContest));

       printf("%d", innerRating);

   }

    



    return 0;

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

using namespace std;

int N,R;

int main () {

	cin >> N >> R;

if(N>=10)

	cout << R << endl;

else {

	cout << R + 100*(10-N) << endl;

}

}


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

#include <string.h>



int main()

{

   int innerRating, displayRating, numContest;



   scanf("%d %d", &numContest, &displayRating);



   if (numContest >= 10)

   {

       printf("%d", displayRating);

   } else

   {

       innerRating = displayRating + (100*(10 - numContest));

       printf("%d", innerRating);

   }

    



    return 0;

}