stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",(double)2*n*acos(-1.0)); 

	return 0;

}




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

using namespace std;



int main() {

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

	printf("%.5lf\n",n*6.28318530717958623200); 

	return 0;

}




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

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",n*6.28318530717958623200); 

	return 0;

}




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

using namespace std;



int main() {

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

	printf("%.5lf\n",n*6.28318530717958623200); 

	return 0;

}




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

#include<algorithm>

#include<queue>

using namespace std;

typedef long long ll;

ll inf = 1000000000;

typedef pair<ll, ll> P;

int main() {

	int a, b;

	cin >> a >> b;

	

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

		for (int j = 1; j <= 1000; j++) {

			

			if ((a<=i*0.08)&&(i*0.08<a+1)&& (b<=j*0.1)&&(j*0.1<b+1)&&i==j) {

				cout << i << endl;

				return 0;

			}

		}

	}

	cout << "-1" << endl;

	return 0;

}


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

#include<iostream>

#include<algorithm>

#include<map>

#include<string>

using namespace std;

typedef long long ll;

typedef pair<ll, ll> P;

ll inf = 1000000007;

int main() {

	int a, b;

	cin >> a >> b;

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

		if ((i * 8) / 100 == a && (i * 10) / 100 == b) {

			cout << i << endl;

			return 0;

		}

	}

	cout << "-1" << endl;

	return 0;

}


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



using namespace std;



// Header files, namespaces,

// macros as defined above

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;



#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>





#define f first

#define s second

#define db long double

#define pb push_back

#define sz(c) (int)(c).size()

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



typedef long long ll;

typedef pair <int , int> ii;

typedef pair <ii , ll> iii;

typedef vector <int> vi;

typedef vector <ii> vii;

typedef vector <iii> viii;

typedef vector <vi> vvi;

typedef vector <vii> vvii;





const int mod = 998244353;

//const db eps = 1e-13;

const ll oo = 1e18;

const int MAX = 1e6+6;

// basic operations

int mul( int a , int b ) {

    return (1ll*a*b)%mod;

}

int add( int a , int b ) {

    return (a+b)%mod;

}

int sub( int a , int b ) {

    return (a-b+mod)%mod;

}

void addSelf( int& a, int b, int m ) {

    a += b;

    b %= m;

}



int exp( int a, int b ) {



    int res = 1;

    while( b ) {



        if ( b % 2 ) {

            res = mul( res, a );

        }

        a = mul(a, a);

        b >>= 1;



    }

    return res;

}



//ll gcd[500005][20], A[500005], N, Q, a, b, r;

//void process2() {

//        int i, j;

//        for (i = 0; i < N; i++)

//                gcd[i][0] = i;

//        for (j = 1; 1 << j <= N; j++)

//                for (i = 0; i + (1 << j) - 1 < N; i++)

//                        gcd[i][j] = __gcd(gcd[i][j - 1], gcd[i + (1 << (j - 1))][j - 1]);

//}

//int RMQ(int a, int b) {

//        int k = (int) log2(b - a + 1);

//        return __gcd(gcd[a][k], gcd[b - (1 << k) + 1][k]);

//}



int main()

{

    ios_base::sync_with_stdio(0);cin.tie(0);

    int A, B;

    cin>>A>>B;

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



        if( (int)(0.08*i) == A && (int)(0.10*i) == B ) {

            cout<<i<<"\n";

            return 0;

        }



    }

    cout<<"-1\n";





}

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

#include<algorithm>

#include<math.h>

#include<map>

using namespace std;

map<int,int>mp;

int main()

{

	int a,b,f=0;

	double x,y;

	cin>>a>>b;

	x=a/0.08;y=(a+1)/0.08;

	for(int i=ceil(x);i<y;i++)mp[i]++;

	x=b/0.1;y=(b+1)/0.1;

	for(int i=ceil(x);i<y;i++)

	{

		mp[i]++;

		if(mp[i]>1)

		{

			cout<<i<<endl;

			f=1;

			break;

		}

	}

	if(f==0)cout<<"-1"<<endl;

	return 0;

}

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

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

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

#define debug(x) cerr<<#x<<": "<<(x)<<endl

#define INF      (int)1e9

#define EPS      (double)1e-9

#define MOD      ((int)1e9+7)

using namespace std;

typedef long long     llong;

typedef vector<int>   vi;

typedef vector<vi >   vvi;

typedef vector<vvi >  vvvi;

typedef pair<int,int> pii;

template<class Type_a,class Type_b> bool chmax(Type_a &a,const Type_b &b){if(a<b){a=b;return true;}return false;}

template<class Type_a,class Type_b> bool chmin(Type_a &a,const Type_b &b){if(a>b){a=b;return true;}return false;}

template<class Type> void line(const Type &a){int cnt=0;for(const auto &elem:a){if(cnt++)cout<<' ';cout<<elem;}cout<<endl;}



int main(){

	int a,b;

	cin>>a>>b;

	

	double ans=0;

	while(ans<(int)1e5){

		double tmp=ans*0.08;

		double tmpp=ans*0.1;

		if(a==floor(tmp) and b==floor(tmpp)){

			cout<<ans<<endl;

			return 0;

		}

		

		ans++;

	}

	

	cout<<-1<<endl;

}

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

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

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

#define debug(x) cerr<<#x<<": "<<(x)<<endl

#define INF      (int)1e9

#define EPS      (double)1e-9

#define MOD      ((int)1e9+7)

using namespace std;

typedef long long     llong;

typedef vector<int>   vi;

typedef vector<vi >   vvi;

typedef vector<vvi >  vvvi;

typedef pair<int,int> pii;

template<class Type_a,class Type_b> bool chmax(Type_a &a,const Type_b &b){if(a<b){a=b;return true;}return false;}

template<class Type_a,class Type_b> bool chmin(Type_a &a,const Type_b &b){if(a>b){a=b;return true;}return false;}

template<class Type> void line(const Type &a){int cnt=0;for(const auto &elem:a){if(cnt++)cout<<' ';cout<<elem;}cout<<endl;}



int main(){

	int a,b;

	cin>>a>>b;

	

	REP(i,1400){

		int tmp=i*0.08;

		int tmpp=i*0.1;

		if(tmp==a and tmpp==b){

			cout<<i<<endl;

			return 0;

		}

	}

	

	cout<<-1<<endl;

}

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

#include <string>

#include <algorithm>

#include <utility> 

#include <unordered_set>

#include <vector>

#include <list> 

#include <string>

#include <iterator> 

#include <deque>

#include <array>

#include <forward_list>

#include <queue>

#include <stack>

#include <set>

#include <map>

#include <unordered_set>

#include <unordered_map>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <cmath>

#include <climits>

#include <bitset>

#include <numeric>

using namespace std;





const long double PI = 3.14159265358979323846264338327950;

const int N = 2 * 1e5;





template <class T>

T gcd(T a, T b) {

	if (b == 0) return a;

	return gcd(b, a % b);

}





int main() {

	ios_base::sync_with_stdio(false);

	cin.tie(NULL);

	cout.tie(NULL);



	int a, b, ans;

	cin >> a >> b;

	// cout << "n:" << n << " m:" << m << '\n';

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

		if (2 * i / 25 == a && i / 10 == b) {

			cout << i << '\n';

			return 0;

		}

	}



	cout << -1 << '\n';

}


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

#include <string>

#include <algorithm>

#include <utility> 

#include <unordered_set>

#include <vector>

#include <list> 

#include <string>

#include <iterator> 

#include <deque>

#include <array>

#include <forward_list>

#include <queue>

#include <stack>

#include <set>

#include <map>

#include <unordered_set>

#include <unordered_map>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <cmath>

#include <climits>

#include <bitset>

#include <numeric>

using namespace std;





const long double PI = 3.14159265358979323846264338327950;

const int N = 2 * 1e5;





template <class T>

T gcd(T a, T b) {

	if (b == 0) return a;

	return gcd(b, a % b);

}





int main() {

	ios_base::sync_with_stdio(false);

	cin.tie(NULL);

	cout.tie(NULL);



	int a, b, ans;

	cin >> a >> b;

	// cout << "n:" << n << " m:" << m << '\n';

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

		if (2 * i / 25 == a && i / 10 == b) {

			cout << i << '\n';

			return 0;

		}

	}



	cout << -1 << '\n';

}


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



using namespace std;



typedef long long ll;

typedef pair< ll, ll > pll;

typedef pair< int, int > pii;



const double pi = 3.14159265358979323846;



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

// template<class T> bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }

// template<class T> bool chmin(T &a, const T &b) { if (a>b) { a = b; return 1; } return 0; }

#define MOD 1000000007LL

#define PS(p) cout << setprecision(15) << fixed << p << endl;

#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());

#define ALL(c) c.begin(), c.end()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define MT make_tuple

#define TG0 get< 0 >

#define TG1 get< 1 >

#define TG2 get< 2 >

#define F first

#define S second

#define VL vector< ll >



// to_string(123)

// atoi("123"); atoi(s.c_str());

// "abc".size()

// s.find('+') == string::npos

// 1e18



int main() {

  cin.tie(0);

  ios::sync_with_stdio(false);



  double A, B;

  cin >> A >> B;

  double d8, d10;

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

    d8 = i * 0.08;

    d10 = i * 0.1;

    // cerr << i << " " << d8 << " " << d10 << endl;



    if (floor(d8) == A && floor(d10) == B) {

      cout << i << endl;

      return 0;

    }

  }



  cout << -1 << endl;



  return 0;

}


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



using namespace std;



typedef long long ll;

typedef pair< ll, ll > pll;

typedef pair< int, int > pii;



const double pi = 3.14159265358979323846;



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

// template<class T> bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }

// template<class T> bool chmin(T &a, const T &b) { if (a>b) { a = b; return 1; } return 0; }

#define MOD 1000000007LL

#define PS(p) cout << setprecision(15) << fixed << p << endl;

#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());

#define ALL(c) c.begin(), c.end()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define MT make_tuple

#define TG0 get< 0 >

#define TG1 get< 1 >

#define TG2 get< 2 >

#define F first

#define S second

#define VL vector< ll >



// to_string(123)

// atoi("123"); atoi(s.c_str());

// "abc".size()

// s.find('+') == string::npos

// 1e18



int main() {

  cin.tie(0);

  ios::sync_with_stdio(false);



  ll A, B;

  cin >> A >> B;



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

    double d8 = floor(i * 0.08);

    double d10 = floor(i * 0.1);

    if (d8 == A && d10 == B) {

      cout << i << endl;

      return 0;

    }

  }



  cout << -1 << endl;

  return 0;

}


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

using namespace std;

typedef long long ll;

int main() {

    int A, B;

    cin >> A >> B;

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

        int p1 = 8 * i / 100;

        int p2 = i / 10;

        if (p1 == A && p2 == B) {

            cout << i << "\n";

            return 0;

        }

    }

    cout << "-1\n";

    return 0;

}

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

using namespace std;

typedef long long ll;

int main() {

    int A, B;

    cin >> A >> B;

    int a = A / 2;

    int d = 25 * a % 10;

    int t = B - 25 * a / 10;

    if (t < 0) {

        cout << "-1\n";

        return 0;

    }

    if (A % 2 == 0) {

        if (t == 0) {

            cout << 25 * a << "\n";

        } else {

            if (t > 1) cout << "-1\n";

            else {

                cout << 25 * a + 10 - d << "\n";

            }

        }

    } else {

        if (t == 0 || t > 2) {

            cout << "-1\n";

            return 0;

        }

        if (t == 1) {

            cout << 25 * a + 13 << "\n";

        } else {

            cout << 25 * a + 20 - d << "\n";

        }

    }

    return 0;

}

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

using namespace std;

typedef long long ll;

int main(void){

    int a,b;

    cin>>a>>b;

    int ans=-1;

    for(double i=1;i<=100000;i++){

        if(floor(i*0.08)==a&&floor(i*0.1)==b){

            ans=i;

            break;

        }

    }

    cout<<ans;

}

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

using namespace std;

int main(void){

    double A,B;

    cin>>A>>B;

    int a0=ceil(A/0.08),a1=ceil((A+1)/0.08-1),b0=ceil(B/0.1),b1=ceil((B+1)/0.1-1);

    if(a0<=b1&&b0<=a1) cout<<max(a0,b0);

    else cout<<-1;

}


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

#include <math.h>

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

 

using namespace std;

 

int main() {

  int A, B;

  cin >> A >> B;

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

    int c = floor(i * 0.08);

    int d = floor(i * 0.1);

    if(A == c && B == d){

      cout << i << endl;

      return 0;

    }

  }

  cout << "-1" << endl;

  

}

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

#include <math.h>

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

 

using namespace std;

 

int main() {

  int A, B;

  cin >> A >> B;

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

    int c = floor(i * 0.08);

    int d = floor(i * 0.1);

    if(A == c && B == d){

      cout << i << endl;

      return 0;

    }

  }

  cout << "-1" << endl;

  

}

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

#include<vector>

#include<string>

#include<algorithm>

#include<stack>

#include<queue>

#include<map>

#include<math.h>



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

typedef long long ll;

using namespace std;



int main() {

	int a, b; cin >> a >> b;



	for (int i = 0; i <= 1114514; i++)

	{

		int m = i * 0.08;

		int n = i * 0.1;

		if (m == a && n == b) {

			cout << i << endl;

			return 0;

		}

	}

	cout << -1 << endl;

	return 0;

}

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

#include<vector>

#include<string>

#include<algorithm>

#include<stack>

#include<queue>

#include<map>

#include<functional>

#include<math.h>



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

typedef long long ll;

using namespace std;



int main() {

	int a, b;

	cin >> a >> b;



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

		int zei8 = i * 0.08;

		int zei10 = i * 0.1;

		if (zei8 == a && zei10 == b) {

			cout << i << endl;

			return 0;

		}

	}

	cout << -1 << endl;



	return 0;

}

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

using namespace std;

#define ll long long int

#define ull unsigned long long int

#define dl double

#define PB push_back

#define MP make_pair

#define PPB pop_back

#define FI first

#define SE second

#define IN insert

#define ER erase

#define clean cout.flush()

#define PF push_front

#define PP pop

#define PH push

#define TP top

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

#define REV reverse

#define IOS ios_base::sync_with_stdio(false);

#define inout freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);

//Here I have defined all the things.....have you any problem?



const ll mod=1e9+7;

const ll lim=1e6+10;

ll ara[lim];

ll b[lim];

ll f[lim];

ll m[100010];



//fasting input and output

void faster()

{

    IOS; cin.tie(NULL); cout.tie(NULL);

}



void Chocolate()

{

    ll a,b;

    cin>>a>>b;

    bool chex=true;

    for(int i=0;i<=1000000;i++)

    {

        ll k=i*(0.08);

        ll k1=i*(0.1);

        if(k==a && k1==b)

        {

            chex=true;

            cout<<i;

            return;

        }

    }

    cout<<-1;

}

int main()

{

    faster();

    //inout;

    //if you hack my code you are a bullshit

    /*ll t; cin>>t; while(t--)*/Chocolate();

    return 0;

}

//Remember, "FAILURE IS THE PILLAR OF SUCCESS"


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

using namespace std;

int main()

{

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

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

    int a,b;

    cin>>a>>b;

    bool chex=false;

    for(float i=0;i<=1000000;i++)

    {

        int k=i*(0.08);

        int k1=i*(0.1);

        if(k==a && k1==b)

        {

            chex=true;

            cout<<i;

            return 0;

        }

    }

    cout<<-1;

    return 0;

}

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

#define INF 1e9

#define llINF 1e18

#define MOD 1000000007

#define pb push_back

#define mp make_pair 

#define F first

#define S second

#define ll long long

#define vi vector<ll>

#define vvi vector<vi>

#define BITLE(n) (1LL<<((ll)n))

#define SHIFT_LEFT(n) (1LL<<((ll)n))

#define SUBS(s,f,t) ((s).substr((f),(t)-(f)))

#define ALL(a) (a).begin(),(a).end()

using namespace std;



int main(){

  cin.tie(0);

  ios::sync_with_stdio(false);

  ll a,b;cin>>a>>b;

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

    if((ll)((double)i*0.08) == a &&

       (ll)((double)i*0.1) == b){

      cout<<i<<endl;

      return 0;

    }

  }

  cout<<-1<<endl;

  return 0;

}


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

#define INF 1e9

#define llINF 1e18

#define MOD 1000000007

#define pb push_back

#define mp make_pair 

#define F first

#define S second

#define ll long long

#define vi vector<ll>

#define vvi vector<vi>

#define BITLE(n) (1LL<<((ll)n))

#define SHIFT_LEFT(n) (1LL<<((ll)n))

#define SUBS(s,f,t) ((s).substr((f),(t)-(f)))

#define ALL(a) (a).begin(),(a).end()

#define Max(a) (*max_element(ALL(a)))

#define Min(a) (*min_element(ALL(a)))

using namespace std;



int main(){

  cin.tie(0);

  ios::sync_with_stdio(false);

  ll a,b;cin>>a>>b;

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

    if(i*8/100 == a && i*10/100 == b){

      cout<<i<<endl;

      return 0;

    }

  }

  cout<<-1<<endl;

  return 0;

}

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

using namespace std;



typedef vector< vector<int> > vvi;

typedef vector< vector<bool> > vvb;

typedef vector< vector<char> > vvc;

typedef vector<int> vi;

typedef vector<bool> vb;

typedef vector<char> vc;

typedef long long ll;



int main(){

    int a,b;

    cin >> a >> b;

    int m,n;

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

        if(i*8/100==a&&i/10==b){

            cout << i << endl;

            return 0;

        }

    }

    cout << "-1" << endl;

    return 0;



}

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

using namespace std;



typedef vector< vector<int> > vvi;

typedef vector< vector<bool> > vvb;

typedef vector< vector<char> > vvc;

typedef vector<int> vi;

typedef vector<bool> vb;

typedef vector<char> vc;

typedef long long ll;



int main(){

    int a,b;

    cin >> a >> b;

    int m,n;

    m=a*100/8;

    if(m*8/100!=a) m++;

    n=b*10;

    //cout << m << " " << n << endl;

    if(m>n){

        if(m/10==b){

            cout << m << endl;

            return 0;

        }

    }else{

        if(n*8/100==a){

            cout << n << endl;

            return 0;

        }

    }

    cout << "-1" << endl;

    return 0;

}

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



using namespace std;

const int N=2e5+5,mod=1e9+7;

#define ll long long

ll a[N],b[N];

ll cum[N];

ll ans=0,R;

ll n,k;

bool valid(int r)

{

    ans=0;

    ll t=k;

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

    {

        ll idx=lower_bound(b,b+n,r-a[i])-b;

        if(idx==n) continue;

        idx=n-1-idx;

        if(idx<i) continue;

        ll sz=idx-i+1;

        t-=sz*2-1;

        ll sum=cum[idx];

        if(i) sum-=cum[i-1];

        ans+=sum*2+a[i]*(sz-1)*2;

    }

    R=t;

    return t>=0;

}

ll bs()

{

    ll s=0,e=2e5+5,mid;

    while(s<e)

    {

        mid=(s+e)/2;

        if(valid(mid)) e=mid;

        else s=mid+1;

    }

    return s;

}

int main()

{

    ios_base::sync_with_stdio(0);

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

    cin>>n>>k;

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

        cin>>a[i],b[i]=a[i];

    sort(a,a+n);

    sort(b,b+n);

    reverse(a,a+n);

    cum[0]=a[0];

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

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



    ll B=bs();

    valid(B);

    cout<<ans+R*(B-1)<<endl;

    return 0;

}


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

#include <cctype>

#include <algorithm>

#define int long long



int n, m;

int a[100010], fs[100010];

int l = 0, r = 200010, ans, cnt, res;



int read() {

    int ret, f = 1;

    char ch;

    while(!isdigit(ch = getchar())) (ch == '-') && (f = -1);

    for(ret = ch - '0'; isdigit(ch = getchar()); ret *= 10, ret += ch - '0');

    return ret * f;

}



void print(int x) {

    if(x < 0) putchar('-'), x = -x;

    if(x > 9) print(x / 10);

    putchar(x % 10 + '0');

}



signed main() {

    n = read(), m = read();

    for(int i = 1; i <= n; ++i) a[i] = read();

    std::sort(a + 1, a + n + 1);

    for(int i = 1; i <= n; ++i) fs[i] = fs[i - 1] + a[i];

    while(l <= r) {

        int mid = (l + r) >> 1;

        cnt = res = 0;

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

            int pos = std::lower_bound(a + 1, a + n + 1, mid - a[i]) - a;

            res += fs[n] - fs[pos - 1] + a[i] * (n - pos + 1); 

            cnt += n - pos + 1;

        }

        if(cnt >= m) ans = mid, l = mid + 1;

        else r = mid - 1;

    }

    print(res - ans * (cnt - m));

    return 0;

}

// Fastest known solution for this problem: