stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
//i hate _____

#include<bits/stdc++.h>



#define ll long long int 

#define ld long double 

#define pb push_back

#define mk make_pair

#define ii pair<int,int>



using namespace std;

double pi=2*acos(0.0);



/*freopen("input.txt","r",stdin);

freopen("output.txt","w",stdout);*/



template<typename T> 

ostream& operator<<(ostream &os, const vector<T> &v) { 

    os << '{'; 

    for (const auto &x : v) os << " " << x;

        return os << '}'; 

}



void solve(){

    int n; cin>>n;

    int ans=n+(n*n)+(n*n*n);

    cout << ans << endl;

}



int main()

{

    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);



    int test_cases=1; 

    //cin>>test_cases;



    for (int tc=1;tc<=test_cases;tc++){

        

        solve();

        //cout << "Case " << tc << ": " << solve() <<endl;

        //printf("Case %d: %.10lf",tc,ans);

    }

    return 0;

}

/*

    problems are the sign of life

*/


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>



using namespace std;



int main()

{

    int a;

    cin>>a;

    cout<<a+(a*a)+(a*a*a)<<endl;

    return 0;



}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



int main()

{

    int a;

    cin>>a;

    cout<<a + a*a +a*a*a;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <string>

using namespace std;



int a, b, c;



int main () {

    cin >> a ;

    b = a*a ;

    c = a*a*a ;

    cout << a+b+c << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int a;



int main() {

    cin >> a;

    cout << a+a*a+a*a*a << endl;

}

// itung lg

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



//B - Calc

int h;

int main() {

    cin >> h;

    cout << h + h*h + h*h*h << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int a;



//heyyyy



int main() {

    cin >> a;

    cout << a+a*a+a*a*a << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int x;



int main() {

    // aulia 

    cin >> x;

    cout << x + x*x + x*x*x << endl;



}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

	cin >> a;

	cout << a + a*a + a*a*a;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int a, result;



int main () {

    cin >> a;

    result = a + a*a + a*a*a;

    cout << result << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int a;

int main() {

    cin >> a;

    cout <<a+a*a+a*a*a<< endl;



}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

    

    

    

    long long int n;

    scanf("%lld", &n);

    printf("%lld", n + n*n + n*n*n);









}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main()

{

    int a;

    cin >> a;

    cout << a * (1 + a * (1 + a)) << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

main(){int a;scanf("%d",&a);printf("%d\n",a*(1+a*(1+a)));}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#define ss long long int

using namespace std;



int main()

{

	ss a;

	cin >> a;

	a = a + (a*a) + (a*a*a);

	cout << a << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main()

{

    int a,b;

    cin>>a;

    b=a+a*a+a*a*a;

    cout<<b;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<string.h>

int main()

{

    long long int s= 0;

    int n =0;

    std::cin>>n;

    s = n+ n*n + n*n*n;

    std::cout<<s<<std::endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int a;



int main() {

    cin >> a;

    cout << a+a*a+a*a*a << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int a=2;



int main() {

    cin >> a;

    cout << a+a*a+a*a*a << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int a,b;

int main() {

	cin>>a;

	b=a+a*a+a*a*a;

	cout<<b<<endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int a;



int main() {

    cin >> a;

    cout << a+a*a+a*a*a << endl;

}

//kopa

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int a, result;



int main() {

    cin>>a;

    result = a + a*a + a*a*a;

    cout<<result<<endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

//zakha



int a,result;

int main () {

    cin >> a;

    result= a + a*a + a*a*a;

    cout << result << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int t;

	scanf("%d", &t);

	int ans = t + (t*t)+ (t*t*t);

	printf("%d", ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>



using namespace std;



int main() {

  int a;

  cin >> a;

  int res = 0;

  for (int i = 0; i < 3; ++i) res = (res + 1) * a;

  cout << res << endl;

}


// Optimized solution to the same problem (faster):
#include<cstdio>

int main(){int a;std::scanf("%d",&a);std::printf("%d",a+a*a+a*a*a);}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;

int main()

{

    int a;

    cin>>a;

    cout<<(a+a*a+a*a*a)<<endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int a,sum;

	scanf("%d",&a);

	sum=a+(a*a)+(a*a*a);

	printf("%d",sum);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main()

{

int n;

cin>>n;

cout<<n+(n*n)+(n*n*n)<<endl;

return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int a,sum;

	scanf("%d",&a);

	sum=a+(a*a)+(a*a*a);

	printf("%d",sum);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int a, b;



int main() {

    cin >> a >> b;

    cout << a+(a*a)+(a*a*a) << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int a,sum;

	scanf("%d",&a);

	sum=a+(a*a)+(a*a*a);

	printf("%d",sum);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int a;



int main() {

    /*Jovando Haryo K

    X2*/

    cin >> a;

    cout << a+a*a+a*a*a << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int a,sum;

	scanf("%d",&a);

	sum=a+(a*a)+(a*a*a);

	printf("%d",sum);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main(void)

{

    short int a;

    cin>>a;



    int ans = a + pow(a,2) + pow(a,3);

    cout<<ans<<endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main()



{

    long long int a;

    scanf("%lld", &a);

    printf("%lld", a + (a * a) + (a * a * a));



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;



int main()

{

    int a;

    long int sum;

    cin>>a;

    sum=a+a*a+a*a*a;

    cout<<sum<<endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main()



{

    long long int a;

    scanf("%lld", &a);

    printf("%lld", a + (a * a) + (a * a * a));



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main()

{

	long long a;

	cin >> a;

	cout << a + a * a + a * a * a << endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main()



{

    long long int a;

    scanf("%lld", &a);

    printf("%lld", a + (a * a) + (a * a * a));



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int a;



int main() {

    cin >> a;

    cout << a+a*a+a*a*a << endl;

}



// hai

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main()



{

    long long int a;

    scanf("%lld", &a);

    printf("%lld", a + (a * a) + (a * a * a));



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;



int main()

{

	int x;

	cin>>x;

	int ans= x+(x*x)+(x*x*x);

	cout<<ans;

	

	return 0;

}

// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cmath>

using namespace std;

int main()

{

    int a,val;

    cin>>a;

    val=a+pow(a,2)+pow(a,3);

    cout<<val;



}


// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;



int main()

{

  int a;

  cin>>a;

  cout<<a+a*a+a*a*a;

  return 0;

}

// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#define ll long long

#define pb push_back

#define mp make_pair

#define vi vector <int>

#define vii vector <int>::iterator 

#define vd vector <double>

#define vdd vector <double>::iterator

#define vs vector <string>

#define vss vector <string>::iterator

#define vc vector <char>

#define vcc vector <char>::iterator

#define maxx(a,b,c) max(a,max(b,c))

#define minn(a,b,c) min(a,min(b,c))

#define SORT(x)     sort(x.begin(),x.end())

#define fill(x,y)   memset(x, y, sizeof(x))

#define PI 2*acos(0.0)

#define fio ios::sync_with_stdio(false);cin.tie(0)

using namespace std;

int main(){

   ll a;

   cin >> a;

   cout << a*(1+(a*(a+1))) << endl;

}

// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

int main(){

    int a;

    std::cin >> a;

    a=a+a*a+a*a*a;

    std::cout << a << std::endl;

}


// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):


                                 /*Bismillahir Rahmanir Rahim*/





#include<bits/stdc++.h>

#include<cstring>

#include<vector>

#include<map>

#include<set>

#define ll long long int

#define dd double

using namespace std;



int main()

{

    ll t;

    cin>>t;

    ll ans=t+pow(t,2)+pow(t,3);

    cout<<ans<<endl;



}

//Apna Time Aayega :)

// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<algorithm>

#include<cstring>

#include<cmath>

using namespace std;

int main()

{

      int a,b;

     cin>>a;

     b=a+a*a+a*a*a;

     cout<<b<<endl;

     return 0;

}


// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



int main()

{

    long long a,s;

    cin>>a;

    s=a+a*a+a*a*a;

    cout<<s<<endl;

    return 0;

}

// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>



using namespace std;



#define TC ll t; cin >> t; while(t--)

typedef long long ll;



int main()

{

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

    //freopen("output.txt", "w", stdout);

    ll a; cin >> a;

    cout << (a)+(a*a)+(a*a*a) << endl;

    return 0;

}


// Optimized solution to the same problem (faster):
///a. calc

#include <stdio.h>

int main()

{

    long long int a;

    scanf("%lld",&a);

    printf("%lld",a+a*a+a*a*a);



    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <iomanip>

#include <cmath>

#include <vector>

#include <queue>

#include <limits>

#include <algorithm>

#include <set>

#include <string>

using namespace std;



static int32_t A, B, C, D;

static vector<vector<double>> memo;



static double get_concentration(int32_t water, int32_t sugar)

{

	return water + sugar == 0 ? 0.0 : sugar / (water * 100.0 + sugar);

}



static double dp(int32_t water, int32_t sugar)

{

	if (memo[water][sugar] >= 0.0)

		return memo[water][sugar];



	double res = get_concentration(water, sugar);

	res = max(res, dp(water + A, sugar));

	res = max(res, dp(water + B, sugar));

	res = max(res, dp(water, sugar + C));

	res = max(res, dp(water, sugar + D));

	memo[water][sugar] = res;

	return memo[water][sugar];

}



int main()

{

	int32_t E, F;

	cin >> A >> B >> C >> D >> E >> F;



	memo.resize(F + 1);

	for (int32_t i = 0; i < F + 1; i++) {

		memo[i].resize(F + 1);

		fill(begin(memo[i]), end(memo[i]), -1.0);

	}

	for (int32_t water = 0; water < F + 1; water++) {

		for (int32_t sugar = 0; sugar < F + 1; sugar++) {

			if (water * 100 + sugar > F || water * E < sugar)

				memo[water][sugar] = 0.0;

		}

	}



	double _max = dp(0, 0);

	for (int32_t water = 0; water < F + 1; water++) {

		for (int32_t sugar = 0; sugar < F + 1; sugar++) {

			if (memo[water][sugar] == _max && get_concentration(water, sugar) == _max) {

				if (water == 0 && sugar == 0)

					water = A;

				cout << (water * 100 + sugar) << " " << sugar << endl;

				return 0;

			}

		}

	}



	return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <iomanip>

#include <cmath>

#include <vector>

#include <queue>

#include <limits>

#include <algorithm>

#include <set>

#include <string>

using namespace std;



static double get_concentration(int32_t water, int32_t sugar)

{

	return water + sugar == 0 ? 0.0 : 1.0 * sugar / (water + sugar);

}



int main()

{

	int32_t A, B, C, D, E, F;

	cin >> A >> B >> C >> D >> E >> F;



	double _max = 0.0;

	int32_t max_total = 0, max_sugar = 0;

	for (int32_t a = 0; a <= F; a += 100 * A) {

		for (int32_t b = 0; a + b <= F; b += 100 * B) {

			for (int32_t c = 0; a + b + c <= F; c += C) {

				for (int32_t d = 0; a + b + c + d <= F; d += D) {

					if ((a + b) / 100 * E < c + d)

						continue;

					double concentration = get_concentration(a + b, c + d);

					if (_max < concentration) {

						_max = concentration;

						max_total = a + b + c + d;

						max_sugar = c + d;

					}

				}

			}

		}

	}

	if (max_sugar == 0)

		max_total = 100 * A;



	cout << max_total << " " << max_sugar << endl;



	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):


// C - Sugar Water



#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

// const int INF = 2147483647;

// const ll INF = 9223372036854775807;

// const ll MOD = 1e9 + 7;



const int MAX = 4000;

bool dp[MAX][MAX]; // dp[a][b]: 水i(g), 砂糖j(g)の組み合わせがあれば1



int main() {

	int A, B, C, D, E, F;

	cin >> A >> B >> C >> D >> E >> F;



	dp[0][0] = 1;



	for (int a=0; a<=F; a++) {

		for (int b=0; b<=F; b++) {

			if (dp[a][b] == 0) continue;



			if (a + 100*A + b <= F) {

				dp[a + 100*A][b] = 1;

			}



			if (a + 100*B + b <= F) {

				dp[a + 100*B][b] = 1;

			}



			if ((b + C) * (100 + E) <= E * (a + (b + C)) && a + (b + C) <= F) {

				dp[a][b+C] = 1;

			}



			if ((b + D) * (100 + E) <= E * (a + (b + D)) && a + (b + D) <= F) {

				dp[a][b+D] = 1;

			}

		}

	}



	int w = 100*A, s = 0;

	for (int a=0; a<=F; a++) {

		for (int b=0; b<=F; b++) {

			if (dp[a][b] == 0) continue;



			if (b * (w + s) > s * (a + b)) {

				w = a;

				s = b;

			}

		}

	}



	cout << w + s << " " << s << endl;



	return 0;

}

// Optimized solution to the same problem (faster):


// C - Sugar Water



#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

//const int INF = 2147483647;

// const ll INF = 9223372036854775807;

// const ll MOD = 1e9 + 7;



const int MAX = 4000;

bool dp[MAX][MAX]; // dp[a][b]: 水i(g), 砂糖j(g)の組み合わせがあれば1



int main() {

	int A, B, C, D, E, F;

	cin >> A >> B >> C >> D >> E >> F;



	set<int> water;

	set<int> sugar;



	for (int i=0; i*100*A<=F; i++) {

		for (int j=0; j*100*B<=F; j++) {

			if ((i*100*A + j*100*B != 0) && (i*100*A + j*100*B <= F)) {

				water.insert(i*100*A + j*100*B);

			}

		}

	}



	for (int i=0; i*C<=F; i++) {

		for (int j=0; j*D<=F; j++) {

			if (i*C + j*D <= F) {

				sugar.insert(i*C + j*D);

			}

		}

	}



	int ans_w = 100*A;

	int ans_s = 0;

	for (int w : water) {

		for (int s : sugar) {

			if (s * (100 + E) > E * (w + s)) continue;

			if (w + s > F) continue;



			if (s * (ans_w + ans_s) > ans_s * (w + s)) {

				ans_w = w;

				ans_s = s;

			}

		}

	}



	cout << ans_w + ans_s << " " << ans_s << endl;



	return 0;

}

// Fastest known solution for this problem: