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.260089330214332x):
#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 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.259989873706417x):
#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;



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

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.260096229356798x):
#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{

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

	}

}

// 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) ;

	}

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

	int inner;

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

	inner = 100 * (10-K);

	

	if(K<10)

	{

		printf("%d\n", inner+R);

	}

	else if(K>=10)

	{

		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 K, R;

	int inner;

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

	inner = 100 * (10-K);

	

	if(K<10)

	{

		printf("%d\n", inner+R);

	}

	else if(K>=10)

	{

		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 K, R;

	int inner;

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

	inner = 100 * (10-K);

	

	if(K<10)

	{

		printf("%d\n", inner+R);

	}

	else if(K>=10)

	{

		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 K, R;

	int inner;

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

	inner = 100 * (10-K);

	

	if(K<10)

	{

		printf("%d\n", inner+R);

	}

	else if(K>=10)

	{

		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 K, R;

	int inner;

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

	inner = 100 * (10-K);

	

	if(K<10)

	{

		printf("%d\n", inner+R);

	}

	else if(K>=10)

	{

		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 K, R;

	int inner;

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

	inner = 100 * (10-K);

	

	if(K<10)

	{

		printf("%d\n", inner+R);

	}

	else if(K>=10)

	{

		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 K, R;

	int inner;

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

	inner = 100 * (10-K);

	

	if(K<10)

	{

		printf("%d\n", inner+R);

	}

	else if(K>=10)

	{

		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 K, R;

	int inner;

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

	inner = 100 * (10-K);

	

	if(K<10)

	{

		printf("%d\n", inner+R);

	}

	else if(K>=10)

	{

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



int main() {

	int a, b;

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

	

	if(a < 10) {

		a = 100 * (10 - a);

		b = b + a;

		printf("%d", b);

	} else {

		printf("%d", b);

	}

	

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



int main() {

	int a, b;

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

	

	if(a < 10) {

		a = 100 * (10 - a);

		b = b + a;

		printf("%d", b);

	} else {

		printf("%d", b);

	}

	

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



int main() {

	int a, b;

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

	

	if(a < 10) {

		a = 100 * (10 - a);

		b = b + a;

		printf("%d", b);

	} else {

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



int main() {

	int a, b;

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

	

	if(a < 10) {

		a = 100 * (10 - a);

		b = b + a;

		printf("%d", b);

	} else {

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



int main() {

	int a, b;

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

	

	if(a < 10) {

		a = 100 * (10 - a);

		b = b + a;

		printf("%d", b);

	} else {

		printf("%d", b);

	}

	

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



int main() {

	int a, b;

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

	

	if(a < 10) {

		a = 100 * (10 - a);

		b = b + a;

		printf("%d", b);

	} else {

		printf("%d", b);

	}

	

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



int main() {

	int a, b;

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

	

	if(a < 10) {

		a = 100 * (10 - a);

		b = b + a;

		printf("%d", b);

	} else {

		printf("%d", b);

	}

	

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



int main() {

	int a, b;

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

	

	if(a < 10) {

		a = 100 * (10 - a);

		b = b + a;

		printf("%d", b);

	} else {

		printf("%d", b);

	}

	

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



int main()

{

    int N,R,hasil;



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

    if (N<10){

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

    }

    else{

        hasil= R;

    }

    printf("%d",hasil);



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



int main()

{

    int N,R,hasil;



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

    if (N<10){

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

    }

    else{

        hasil= R;

    }

    printf("%d",hasil);



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



int main()

{

    int N,R,hasil;



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

    if (N<10){

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

    }

    else{

        hasil= R;

    }

    printf("%d",hasil);



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



int main()

{

    int N,R,hasil;



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

    if (N<10){

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

    }

    else{

        hasil= R;

    }

    printf("%d",hasil);



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



int main()

{

    int N,R,hasil;



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

    if (N<10){

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

    }

    else{

        hasil= R;

    }

    printf("%d",hasil);



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



int main()

{

    int N,R,hasil;



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

    if (N<10){

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

    }

    else{

        hasil= R;

    }

    printf("%d",hasil);



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



int main()

{

    int N,R,hasil;



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

    if (N<10){

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

    }

    else{

        hasil= R;

    }

    printf("%d",hasil);



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



int main()

{

    int N,R,hasil;



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

    if (N<10){

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

    }

    else{

        hasil= R;

    }

    printf("%d",hasil);



    return 0;

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

using namespace std;

int main ()

{

	int n,r;

	while(cin>>n>>r)

	{

		int sum;

		if(n<10)

		{

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

			cout<<sum<<endl;

		}

		else

		{

			cout<<r<<endl;

		}

	}

	return 0;

} 

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

int main(){

	int N;

	int R;

	scanf("%d",&N);

	scanf("%d",&R);

	

	if(N>=10){

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

	}

	else if(N<10){

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

	}

	

	

	

	

	

	

	

	

	

	

	

	return 0;

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

using namespace std;

int main()

{

	int a,b;

	cin>>a>>b;

	if(a<=10)

	{

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

	}

	else cout<<b<<endl;

	return 0;

 } 

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

int main(){

	int N;

	int R;

	scanf("%d",&N);

	scanf("%d",&R);

	

	if(N>=10){

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

	}

	else if(N<10){

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

	}

	

	

	

	

	

	

	

	

	

	

	

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

int main(){

	int N;

	int R;

	scanf("%d",&N);

	scanf("%d",&R);

	

	if(N>=10){

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

	}

	else if(N<10){

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

	}

	

	

	

	

	

	

	

	

	

	

	

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

int main(){

	int N;

	int R;

	scanf("%d",&N);

	scanf("%d",&R);

	

	if(N>=10){

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

	}

	else if(N<10){

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

	}

	

	

	

	

	

	

	

	

	

	

	

	return 0;

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

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

using namespace std;





int main()

{

	int n,r;

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

	int ans;

	if(n<10)

	{

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

	}

	else ans=r;

	printf("%d",ans);

}

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

int main(){

	int N;

	int R;

	scanf("%d",&N);

	scanf("%d",&R);

	

	if(N>=10){

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

	}

	else if(N<10){

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

	}

	

	

	

	

	

	

	

	

	

	

	

	return 0;

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

using namespace std;

int main ()

{

	int n,r;

	while(cin>>n>>r)

	{

		int sum;

		if(n<10)

		{

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

			cout<<sum<<endl;

		}

		else

		{

			cout<<r<<endl;

		}

	}

	return 0;

} 

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

int main ()

{

int N,R,I;



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



if (N>=10){

	printf("%d", R);

}

else {

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

	printf("%d",I);	

}

	return 0;

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

using namespace std;

int main()

{

	int a,b;

	cin>>a>>b;

	if(a<=10)

	{

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

	}

	else cout<<b<<endl;

	return 0;

 } 

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

int main ()

{

int N,R,I;



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



if (N>=10){

	printf("%d", R);

}

else {

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

	printf("%d",I);	

}

	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,I;



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



if (N>=10){

	printf("%d", R);

}

else {

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

	printf("%d",I);	

}

	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,I;



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



if (N>=10){

	printf("%d", R);

}

else {

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

	printf("%d",I);	

}

	return 0;

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

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

using namespace std;





int main()

{

	int n,r;

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

	int ans;

	if(n<10)

	{

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

	}

	else ans=r;

	printf("%d",ans);

}

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

int main ()

{

int N,R,I;



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



if (N>=10){

	printf("%d", R);

}

else {

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

	printf("%d",I);	

}

	return 0;

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

using namespace std;

int main ()

{

	int n,r;

	while(cin>>n>>r)

	{

		int sum;

		if(n<10)

		{

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

			cout<<sum<<endl;

		}

		else

		{

			cout<<r<<endl;

		}

	}

	return 0;

} 

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

int main()

{

	int N,K,R,hasil;

		scanf("%d",&N);

			getchar();	

	scanf("%d",&R);

			getchar();

	

	if(N <=10)

	{

	hasil =	100 * (10-N);

	K = R + hasil;	

		

	}

	else

	{

	K = R;

	

	}

	printf("%d",K);

	

	

	return 0;

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

using namespace std;

int main()

{

	int a,b;

	cin>>a>>b;

	if(a<=10)

	{

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

	}

	else cout<<b<<endl;

	return 0;

 } 

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

int main()

{

	int N,K,R,hasil;

		scanf("%d",&N);

			getchar();	

	scanf("%d",&R);

			getchar();

	

	if(N <=10)

	{

	hasil =	100 * (10-N);

	K = R + hasil;	

		

	}

	else

	{

	K = R;

	

	}

	printf("%d",K);

	

	

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

int main()

{

	int N,K,R,hasil;

		scanf("%d",&N);

			getchar();	

	scanf("%d",&R);

			getchar();

	

	if(N <=10)

	{

	hasil =	100 * (10-N);

	K = R + hasil;	

		

	}

	else

	{

	K = R;

	

	}

	printf("%d",K);

	

	

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

int main()

{

	int N,K,R,hasil;

		scanf("%d",&N);

			getchar();	

	scanf("%d",&R);

			getchar();

	

	if(N <=10)

	{

	hasil =	100 * (10-N);

	K = R + hasil;	

		

	}

	else

	{

	K = R;

	

	}

	printf("%d",K);

	

	

	return 0;

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

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

using namespace std;





int main()

{

	int n,r;

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

	int ans;

	if(n<10)

	{

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

	}

	else ans=r;

	printf("%d",ans);

}

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

int main()

{

	int N,K,R,hasil;

		scanf("%d",&N);

			getchar();	

	scanf("%d",&R);

			getchar();

	

	if(N <=10)

	{

	hasil =	100 * (10-N);

	K = R + hasil;	

		

	}

	else

	{

	K = R;

	

	}

	printf("%d",K);

	

	

	return 0;

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

using namespace std;

int main ()

{

	int n,r;

	while(cin>>n>>r)

	{

		int sum;

		if(n<10)

		{

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

			cout<<sum<<endl;

		}

		else

		{

			cout<<r<<endl;

		}

	}

	return 0;

} 

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



int main(){

	int N,R;

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

	if (N < 10){

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

	}

	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)

	{

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

	}

	else cout<<b<<endl;

	return 0;

 } 

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



int main(){

	int N,R;

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

	if (N < 10){

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

	}

	else if(N >= 10){

		printf("%d",R);

	}

	return 0;

}