stablegradients/pie-gem5-pairs huggingface dataset:
// 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>

#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;



#define ll long long



int main() {

    ll n,r;

    cin>>n>>r;

    if(n>=10)

    {

        cout<<r;

    }

    else {

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

    }

        

    

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.2687010416087094x):
#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;

const int maxn=1e5+233;



int t,n,r;

int main(){

    cin>>n>>r;

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

    else cout<<r<<endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.26890656488618x):
#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{

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

	}

}

// 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<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.259740616046342x):
#include <stdio.h>



int main (){

	

	int n,r,a,b;

	

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

	

	if(n<=10){

		a=100 * (10-n);

		b=r + a;

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

	}else{

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

	}



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.260386241902481x):
#include <stdio.h>



int main (){

	

	int n,r,a,b;

	

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

	

	if(n<=10){

		a=100 * (10-n);

		b=r + a;

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

	}else{

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

	}



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.251186985519654x):
#include <stdio.h>



int main (){

	

	int n,r,a,b;

	

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

	

	if(n<=10){

		a=100 * (10-n);

		b=r + a;

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

	}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,a,b;

	

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

	

	if(n<=10){

		a=100 * (10-n);

		b=r + a;

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

	}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,a,b;

	

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

	

	if(n<=10){

		a=100 * (10-n);

		b=r + a;

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

	}else{

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

	}



return 0;

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

using namespace std;



#define ll long long



int main() {

    ll n,r;

    cin>>n>>r;

    if(n>=10)

    {

        cout<<r;

    }

    else {

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

    }

        

    

    return 0;

}

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



int main (){

	

	int n,r,a,b;

	

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

	

	if(n<=10){

		a=100 * (10-n);

		b=r + a;

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

	}else{

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

	}



return 0;

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

using namespace std;

const int maxn=1e5+233;



int t,n,r;

int main(){

    cin>>n>>r;

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

    else cout<<r<<endl;

    return 0;

}

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



int main (){

	

	int n,r,a,b;

	

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

	

	if(n<=10){

		a=100 * (10-n);

		b=r + a;

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

	}else{

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

	}



return 0;

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

using namespace std;

int main(){

	int n,r;

	cin>>n>>r;

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

	else{

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

	}

}

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



int main (){

	

	int n,r,a,b;

	

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

	

	if(n<=10){

		a=100 * (10-n);

		b=r + a;

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

	}else{

		printf("%d\n",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.268175825854569x):
#include<stdio.h>

int main()

{

	int N,R,K,H;

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

	if(N<10)

	{

		K=100*(10-N);

		H=K+R;

		printf("%d",H);

	}

	else

	{

		printf("%d",R);

	}

}
// 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.268822487120997x):
#include<stdio.h>

int main()

{

	int N,R,K,H;

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

	if(N<10)

	{

		K=100*(10-N);

		H=K+R;

		printf("%d",H);

	}

	else

	{

		printf("%d",R);

	}

}
// 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.259608477604256x):
#include<stdio.h>

int main()

{

	int N,R,K,H;

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

	if(N<10)

	{

		K=100*(10-N);

		H=K+R;

		printf("%d",H);

	}

	else

	{

		printf("%d",R);

	}

}
// 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,K,H;

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

	if(N<10)

	{

		K=100*(10-N);

		H=K+R;

		printf("%d",H);

	}

	else

	{

		printf("%d",R);

	}

}
// 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,K,H;

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

	if(N<10)

	{

		K=100*(10-N);

		H=K+R;

		printf("%d",H);

	}

	else

	{

		printf("%d",R);

	}

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

using namespace std;



#define ll long long



int main() {

    ll n,r;

    cin>>n>>r;

    if(n>=10)

    {

        cout<<r;

    }

    else {

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

    }

        

    

    return 0;

}

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

int main()

{

	int N,R,K,H;

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

	if(N<10)

	{

		K=100*(10-N);

		H=K+R;

		printf("%d",H);

	}

	else

	{

		printf("%d",R);

	}

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

using namespace std;

const int maxn=1e5+233;



int t,n,r;

int main(){

    cin>>n>>r;

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

    else cout<<r<<endl;

    return 0;

}

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

int main()

{

	int N,R,K,H;

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

	if(N<10)

	{

		K=100*(10-N);

		H=K+R;

		printf("%d",H);

	}

	else

	{

		printf("%d",R);

	}

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

using namespace std;

int main(){

	int n,r;

	cin>>n>>r;

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

	else{

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

	}

}

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

int main()

{

	int N,R,K,H;

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

	if(N<10)

	{

		K=100*(10-N);

		H=K+R;

		printf("%d",H);

	}

	else

	{

		printf("%d",R);

	}

}
// 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.268175825854569x):
#include <stdio.h>



int main()

{

  int N;

  int R;

  int K;

  

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

  

 

  if (N < 10) {

	K = 100 * (10 - N);

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

  }

  else {

    printf("%d", R);

  }

 

  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.268822487120997x):
#include <stdio.h>



int main()

{

  int N;

  int R;

  int K;

  

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

  

 

  if (N < 10) {

	K = 100 * (10 - N);

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

  }

  else {

    printf("%d", R);

  }

 

  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.259608477604256x):
#include <stdio.h>



int main()

{

  int N;

  int R;

  int K;

  

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

  

 

  if (N < 10) {

	K = 100 * (10 - N);

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

  }

  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;

  int R;

  int K;

  

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

  

 

  if (N < 10) {

	K = 100 * (10 - N);

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

  }

  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;

  int R;

  int K;

  

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

  

 

  if (N < 10) {

	K = 100 * (10 - N);

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

  }

  else {

    printf("%d", R);

  }

 

  return 0;

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

using namespace std;



#define ll long long



int main() {

    ll n,r;

    cin>>n>>r;

    if(n>=10)

    {

        cout<<r;

    }

    else {

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

    }

        

    

    return 0;

}

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



int main()

{

  int N;

  int R;

  int K;

  

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

  

 

  if (N < 10) {

	K = 100 * (10 - N);

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

  }

  else {

    printf("%d", R);

  }

 

  return 0;

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

using namespace std;

const int maxn=1e5+233;



int t,n,r;

int main(){

    cin>>n>>r;

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

    else cout<<r<<endl;

    return 0;

}

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



int main()

{

  int N;

  int R;

  int K;

  

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

  

 

  if (N < 10) {

	K = 100 * (10 - N);

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

  }

  else {

    printf("%d", R);

  }

 

  return 0;

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

using namespace std;

int main(){

	int n,r;

	cin>>n>>r;

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

	else{

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

	}

}

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



int main()

{

  int N;

  int R;

  int K;

  

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

  

 

  if (N < 10) {

	K = 100 * (10 - N);

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

  }

  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.268961644679193x):
#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 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.269608402403791x):
#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;

if (n >= 10){

    cout << r;

}

else {

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

    cout << x;

}

}




// Faster C++ solution for the same problem (measured speedup: 5.2603930184944x):
#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.26946693151981x):
#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.269367297702457x):
#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;



#define ll long long



int main() {

    ll n,r;

    cin>>n>>r;

    if(n>=10)

    {

        cout<<r;

    }

    else {

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

    }

        

    

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.2692682975567715x):
#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;

const int maxn=1e5+233;



int t,n,r;

int main(){

    cin>>n>>r;

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

    else cout<<r<<endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.269473842961955x):
#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;

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

	else{

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

	}

}

// Faster C++ solution for the same problem (measured speedup: 5.2603930184944x):
#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.268175825854569x):
#include <stdio.h>



int main(){

    int N, R;

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

    if(N<=10){

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

    }else if(N>10){

        printf("%d", R);

    }

    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.268822487120997x):
#include <stdio.h>



int main(){

    int N, R;

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

    if(N<=10){

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

    }else if(N>10){

        printf("%d", R);

    }

    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.259608477604256x):
#include <stdio.h>



int main(){

    int N, R;

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

    if(N<=10){

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

    }else if(N>10){

        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", (100*(10-N)+R));

    }else if(N>10){

        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", (100*(10-N)+R));

    }else if(N>10){

        printf("%d", R);

    }

    return 0;

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

using namespace std;



#define ll long long



int main() {

    ll n,r;

    cin>>n>>r;

    if(n>=10)

    {

        cout<<r;

    }

    else {

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

    }

        

    

    return 0;

}

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



int main(){

    int N, R;

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

    if(N<=10){

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

    }else if(N>10){

        printf("%d", R);

    }

    return 0;

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

using namespace std;

const int maxn=1e5+233;



int t,n,r;

int main(){

    cin>>n>>r;

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

    else cout<<r<<endl;

    return 0;

}

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



int main(){

    int N, R;

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

    if(N<=10){

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

    }else if(N>10){

        printf("%d", R);

    }

    return 0;

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

using namespace std;

int main(){

	int n,r;

	cin>>n>>r;

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

	else{

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

	}

}

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



int main(){

    int N, R;

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

    if(N<=10){

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

    }else if(N>10){

        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.259584942587734x):
#include <stdio.h>

int main () {

	int n, r;

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

	if (n<10) {

		printf("%d\n", r+(1000-100*n)) ;

	}

	else if (n>=10) {

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

	}

}
// 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.260230549335172x):
#include <stdio.h>

int main () {

	int n, r;

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

	if (n<10) {

		printf("%d\n", r+(1000-100*n)) ;

	}

	else if (n>=10) {

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

	}

}
// 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.251031565224339x):
#include <stdio.h>

int main () {

	int n, r;

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

	if (n<10) {

		printf("%d\n", r+(1000-100*n)) ;

	}

	else if (n>=10) {

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

	}

}