stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <iostream>

#include <string>

#include <vector>

#include <deque>

#include <algorithm>

#include <set>

#include <map>

#include <bitset>

#include <cmath>

#include <functional>

#include <iomanip>

#define vll vector<ll>

#define vvvl vector<vvl>

#define vvl vector<vector<ll>>

#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))

#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));

#define re(c, b) for(ll c=0;c<b;c++)

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

typedef long long int ll;

typedef long double ld;

using namespace std;



ll gcd(ll a, ll b){

  if(b<a) swap(a, b);

  ll r = a % b;

  if(r==0) return b;

  while(r!=0) r = a % b, a = b, b = r;

  return a;

}

int main(int argc, char const *argv[]) {

  ll n;std::cin >> n;

  ll s = 0;

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

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

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

        s += gcd(gcd(i, j), k);

      }

    }

  }

  std::cout << s << '\n';

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.9830044744514974x):
#include <iostream>

#include <string>

#include <vector>

#include <deque>

#include <algorithm>

#include <set>

#include <map>

#include <bitset>

#include <cmath>

#include <functional>

#include <iomanip>

#define vll vector<ll>

#define vvvl vector<vvl>

#define vvl vector<vector<ll>>

#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))

#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));

#define re(c, b) for(ll c=0;c<b;c++)

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

typedef long long int ll;

typedef long double ld;

using namespace std;



ll P = 1000000007;

ll mpow(ll a, ll b, ll p = -1){

  ll ret = 1, num = a;

  if(p==-1){

    while(b>0){

      if(b%2) ret *= num;

      num = num * num;

      b /= 2;

    }

  }else{

    while(b>0){

      if(b%2) ret = (ret*num)%p;

      num = (num*num)%p;

      b /= 2;

    }

  }

  return ret;

}

int main(int argc, char const *argv[]) {

  ll n, k;std::cin >> k;

  ll ans = 0;

  n = 3;

  vll num(k+1, 0);

  for(ll i=k;i>0;i--){

    ll tmp = mpow(k/i, n);

    num[i] += tmp;

    for(ll j=2;j*j<=i;j++){

      if(i%j!=0) continue;

      num[j] -= num[i];

      if(j*j!=i) num[i/j] -= num[i];

    }

    if(i!=1) num[1] -= num[i];

  }

  for(ll i=1;i<=k;i++) ans += num[i]*i;

  std::cout << ans << '\n';

  return 0;

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

#include <string>

#include <vector>

#include <deque>

#include <algorithm>

#include <set>

#include <map>

#include <bitset>

#include <cmath>

#include <functional>

#include <iomanip>

#define vll vector<ll>

#define vvvl vector<vvl>

#define vvl vector<vector<ll>>

#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))

#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));

#define re(c, b) for(ll c=0;c<b;c++)

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

typedef long long int ll;

typedef long double ld;

using namespace std;



ll gcd(ll a, ll b){

  if(b<a) swap(a, b);

  ll r = a % b;

  if(r==0) return b;

  while(r!=0) r = a % b, a = b, b = r;

  return a;

}

int main(int argc, char const *argv[]) {

  ll n;std::cin >> n;

  ll s = 0;

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

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

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

        s += gcd(gcd(i, j), k);

      }

    }

  }

  std::cout << s << '\n';

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 4.023524390803943x):
#include <iostream>

#include <vector>

using namespace std;



int main(int argc, char const *argv[]) {

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

  int ans = 0;

  vector<int> num(k+1, 0);

  for(int i=k;i>0;i--){

    int tmp = (k/i);

    tmp = tmp * tmp * tmp;

    num[i] += tmp;

    for(int j=2;j*j<=i;j++){

      if(i%j!=0) continue;

      num[j] -= num[i];

      if(j*j!=i) num[i/j] -= num[i];

    }

    if(i!=1) num[1] -= num[i];

  }

  for(int i=1;i<=k;i++) ans += num[i]*i;

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

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

#include <string>

#include <vector>

#include <deque>

#include <algorithm>

#include <set>

#include <map>

#include <bitset>

#include <cmath>

#include <functional>

#include <iomanip>

#define vll vector<ll>

#define vvvl vector<vvl>

#define vvl vector<vector<ll>>

#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))

#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));

#define re(c, b) for(ll c=0;c<b;c++)

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

typedef long long int ll;

typedef long double ld;

using namespace std;



ll gcd(ll a, ll b){

  if(b<a) swap(a, b);

  ll r = a % b;

  if(r==0) return b;

  while(r!=0) r = a % b, a = b, b = r;

  return a;

}

int main(int argc, char const *argv[]) {

  ll n;std::cin >> n;

  ll s = 0;

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

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

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

        s += gcd(gcd(i, j), k);

      }

    }

  }

  std::cout << s << '\n';

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 4.0250351193886225x):
#include <iostream>

#include <vector>

using namespace std;



int main(int argc, char const *argv[]) {

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

  int ans = 0;

  vector<int> num(k+1, 0);

  for(int i=k;i>0;i--){

    num[i] += (k/i)*(k/i)*(k/i);

    for(int j=2;j*j<=i;j++){

      if(i%j!=0) continue;

      num[j] -= num[i];

      if(j*j!=i) num[i/j] -= num[i];

    }

    if(i!=1) num[1] -= num[i];

    ans += num[i] * i;

  }

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

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

#include <string>

#include <vector>

#include <deque>

#include <algorithm>

#include <set>

#include <map>

#include <bitset>

#include <cmath>

#include <functional>

#include <iomanip>

#define vll vector<ll>

#define vvvl vector<vvl>

#define vvl vector<vector<ll>>

#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))

#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));

#define re(c, b) for(ll c=0;c<b;c++)

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

typedef long long int ll;

typedef long double ld;

using namespace std;



ll gcd(ll a, ll b){

  if(b<a) swap(a, b);

  ll r = a % b;

  if(r==0) return b;

  while(r!=0) r = a % b, a = b, b = r;

  return a;

}

int main(int argc, char const *argv[]) {

  ll n;std::cin >> n;

  ll s = 0;

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

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

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

        s += gcd(gcd(i, j), k);

      }

    }

  }

  std::cout << s << '\n';

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.980735336985041x):
#include <iostream>

#include <vector>

using namespace std;

int main() {

  int k, ans = 0;std::cin >> k;

  vector<int> num(k+1, 0);

  for(int i=k;i>0;i--){

    num[i] += (k/i)*(k/i)*(k/i);

    for(int j=2;j*j<=i;j++){

      if(i%j!=0) continue;

      num[j] -= num[i];

      if(j*j!=i) num[i/j] -= num[i];

    }

    if(i!=1) num[1] -= num[i];

    ans += num[i] * i;

  }

  std::cout << ans << '\n';

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

#include <string>

#include <vector>

#include <deque>

#include <algorithm>

#include <set>

#include <map>

#include <bitset>

#include <cmath>

#include <functional>

#include <iomanip>

#define vll vector<ll>

#define vvvl vector<vvl>

#define vvl vector<vector<ll>>

#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))

#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));

#define re(c, b) for(ll c=0;c<b;c++)

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

typedef long long int ll;

typedef long double ld;

using namespace std;



ll gcd(ll a, ll b){

  if(b<a) swap(a, b);

  ll r = a % b;

  if(r==0) return b;

  while(r!=0) r = a % b, a = b, b = r;

  return a;

}

int main(int argc, char const *argv[]) {

  ll n;std::cin >> n;

  ll s = 0;

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

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

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

        s += gcd(gcd(i, j), k);

      }

    }

  }

  std::cout << s << '\n';

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 4.018091910372292x):
#include <iostream>

using namespace std;



int main() {

  int k, ans = 0;std::cin >> k;

  int num[k+1];

  for(int i=0;i<=k;i++) num[i] = 0;

  for(int i=k;i>0;i--){

    num[i] += (k/i)*(k/i)*(k/i);

    for(int j=2;j*j<=i;j++){

      if(i%j!=0) continue;

      num[j] -= num[i];

      if(j*j!=i) num[i/j] -= num[i];

    }

    if(i!=1) num[1] -= num[i];

    ans += num[i] * i;

  }

  std::cout << ans << '\n';

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

#include <string>

#include <vector>

#include <deque>

#include <algorithm>

#include <set>

#include <map>

#include <bitset>

#include <cmath>

#include <functional>

#include <iomanip>

#define vll vector<ll>

#define vvvl vector<vvl>

#define vvl vector<vector<ll>>

#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))

#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));

#define re(c, b) for(ll c=0;c<b;c++)

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

typedef long long int ll;

typedef long double ld;

using namespace std;



ll gcd(ll a, ll b){

  if(b<a) swap(a, b);

  ll r = a % b;

  if(r==0) return b;

  while(r!=0) r = a % b, a = b, b = r;

  return a;

}

int main(int argc, char const *argv[]) {

  ll n;std::cin >> n;

  ll s = 0;

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

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

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

        s += gcd(gcd(i, j), k);

      }

    }

  }

  std::cout << s << '\n';

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.980735336985041x):
#include <iostream>

#include <vector>



int main() {

  int k, ans = 0;std::cin >> k;

  std::vector<int> num(k+1);

  for(int i=k;i>0;i--){

    int t = k/i;

    num[i] += t*t*t;

    for(int j=2;j*j<=i;j++){

      if(i%j!=0) continue;

      num[j] -= num[i];

      if(j*j!=i) num[i/j] -= num[i];

    }

    if(i!=1) num[1] -= num[i];

    ans += num[i] * i;

  }

  std::cout << ans << '\n';

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

using namespace std;



int gcd(int a, int b) {

    if(b == 0) return a;

    else return gcd(b, a%b);

}



int gcd(int a, int b, int c) {

    return gcd(a, gcd(b,c));

}



int main() {

    int K;

    cin >> K;

    long long res = 0LL;

    for(int a = 1; a <= K; ++a) {

        for(int b = 1; b <= K; ++b) {

            for(int c = 1; c <= K; ++c) {

                res += gcd(a,b,c);

            }

        }

    }

    cout << res << endl;

    return 0;

}

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

using namespace std;



const int MAX_N = 210;

int GCD[MAX_N][MAX_N];



int gcd(int a, int b) {

    if(b == 0) return a;

    else return gcd(b, a%b);

}



int main() {

    int K;

    cin >> K;

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

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

            GCD[i][j] = GCD[j][i] = gcd(i,j);

        }

    }

    long long res = 0LL;

    for(int a = 1; a <= K; ++a) {

        for(int b = 1; b <= K; ++b) {

            for(int c = 1; c <= K; ++c) {

                res += GCD[a][GCD[b][c]];

            }

        }

    }

    cout << res << endl;

    return 0;

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

using namespace std;

int main(){

  int K;

  cin >> K;

  int64_t ans = 0;

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

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

      for(int k=1; k<=K; k++){

        int x = gcd(i,j);

        ans += gcd(x,k);

      }

    }

  }

  cout << ans << endl;

}

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

using namespace std;

int main(){

  int K;

  cin >> K;

  int64_t ans = 0;

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

    for(int j=i; j<=K; j++){

      for(int k=j; k<=K; k++){

        int x = gcd(gcd(i,j),k);

        if(i == j && j == k){

          ans += x;

        }

        else if((i == j && j != k) || (i != j && j == k)){

          ans += x*3;

        }

        else{

          ans += x*6;

        }

      }

    }

  }

  cout << ans << endl;

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



using namespace std;



int main()

{

    int n,i,ans=0,count=0,j,in[100],m,low2,low1,k,l;



    cin >> n ;

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

    {

        for(j=1; j<=n; j++)

        {

            for(k=1; k<=n; k++)

            {

                low1 = min(i,j);

                low2 = min(low1,k);

                for(l=low2;l>0;l--)

                {

                    if(i%l == 0 && j%l == 0 && k%l == 0 )

                    {

                        ans = ans + l;

                        break;

                    }

                }

            }

        }

    }

    cout << ans;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.990575956091838x):
#include<iostream>

#include<stdio.h>

#include<algorithm>

#include<string.h>

#include<math.h>

#include<stack>

#include<queue>

#include<string>

#include<deque>

#include<set>

#include<vector>

#include<map>

using namespace std;

long long sum=0;

int gcd(int a,int b,int c)

{

    int x=0;

    if(a<b)

        swap(a,b);

    while(a%b!=0)

    {

        x=a%b;

        a=b;

        b=x;

    }

    if(b<c)

        swap(b,c);

    while(b%c!=0)

    {

        x=b%c;

        b=c;

        c=x;

    }

    return c;

}

int main()

{

    int k,a=1,b=1,c=1;

    scanf("%d",&k);

    for(a=1,b=1,c=1;a<=k&&b<=k&&c<=k;)

    {

        sum+=gcd(a,b,c);

        for(int i=1;a+i<=k;i++)

        {

            sum+=gcd(a+i,b,c);

        }

        for(int i=1;b+i<=k;i++)

        {

            sum+=gcd(a,b+i,c);

        }

        for(int i=1;c+i<=k;i++)

        {

            sum+=gcd(a,b,c+i);

        }

        for(int i=1;a+i<=k;i++)

        {

            for(int j=1;b+j<=k;j++)

                sum+=gcd(a+i,b+j,c);

        }

        for(int i=1;a+i<=k;i++)

        {

            for(int j=1;c+j<=k;j++)

                sum+=gcd(a+i,b,c+j);

        }

        for(int i=1;b+i<=k;i++)

        {

            for(int j=1;c+j<=k;j++)

                sum+=gcd(a,b+i,c+j);

        }

        a++;

        b++;

        c++;

    }

    printf("%lld\n",sum);

    return 0;

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

using namespace std;

using pp=pair<int,int>;



int gcd(int a, int b, int c) {

  int m, n;

  for (int i=1; i<=min(a,b); i++) {

    if (a%i==0 && b%i==0) {m=i;}

  }

  for (int i=1; i<=min(m,c); i++) {

    if (m%i==0 && c%i==0) {n=i;}

  }

  return n;

}





int main() {

  int K, S=0;

  cin >> K;

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

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

      for (int k=1; k<=K; k++) {

        S+=gcd(i,j,k);

      }

    }

  }

  cout << S << endl;

}

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

using namespace std;

using pp=pair<int,int>;



int gcd(int a, int b, int c) {

  int m, n;

  while (b!=0) {

    m=a%b;

    a=b;

    b=m;

  }

  m=a;

  

  while (c!=0) {

    n=m%c;

    m=c;

    c=n;

  }

  n=m;

  return n;

}





int main() {

  int K, S=0;

  cin >> K;

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

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

      for (int k=1; k<=K; k++) {

        S+=gcd(i,j,k);

      }

    }

  }

  cout << S << endl;

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

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

using namespace std;

typedef long long ll;



int gcd(int x, int y)

{

  return y ? gcd(y,x%y) : x;

}



int main()

{

  int k; cin >> k;

  ll ans = 0;

  for (int p=1; p<=k; p++)

    for (int q=1; q<=k; q++)

      for (int r=1; r<=k; r++)

        ans += gcd(gcd(p, q), r);

  cout << ans << endl;

  return 0;

}

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

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

using namespace std;

typedef long long ll;



int gcd(int x, int y)

{

  return y ? gcd(y,x%y) : x;

}



int main()

{

  int k; cin >> k;

  ll ans = 0;

  for (int p=1; p<=k; p++)

  {

    ans += p;

    for (int q=p+1; q<=k; q++)

    {

      ans += gcd(p, q) * 6;

      for (int r=q+1; r<=k; r++)

        ans += gcd(gcd(p, q), r) * 6;

    }

  }

  cout << ans << endl;

  return 0;

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

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

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

#define rep1(i,n) for(int i=1;i<=int(n);i++)

#define per(i,n) for(int i=int(n)-1;i>=0;i--)

#define per1(i,n) for(int i=int(n);i>0;i--)

#define foreach(i,n) for(auto &&i:n)

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

#define SORT(x) sort(all(x))

#define REV(x) reverse(all(x))

#define MAX(x) *max_element(all(x))

#define MIN(x) *min_element(all(x))

#define LOWitr(x, n) lower_bound(all(x), n)

#define UPRitr(x, n) upper_bound(all(x), n)

#define cii(x) int x;cin >> x

#define cill(x) LL x;cin >> x

#define cis(x) string x;cin >> x

#define co(x) cout << x << endl

#define dump(x)  cout << #x << " = " << (x) << endl

#define truecheck assert

#define pb push_back

#define mp make_pair

#define F first

#define S second

using namespace std;

typedef long long LL;

typedef long long int64;

typedef vector<int> VI;

typedef vector<LL> VL;

typedef vector<VI> VVI;

typedef vector<string> VS;

typedef pair<int, int> PII;

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

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

template<class T,class U>void vcin(T &v, U n){rep(i, n){typename T::value_type a;cin >> a;v.pb(a);}}

const int INF = 1e9, MOD = 1e9 + 7;

const LL LLINF = 1e16;



int main() {

    fastcin();

    cout << fixed << setprecision(10);

    cii(k);

    int64 ans=0;

    function<int64(int64, int64)> gcd = [&gcd](int64 x, int64 y){

        return !y ? x : gcd(y, x % y);

    };

    rep1(i, k){

        rep1(j, k){

            rep1(y, k){

                ans += gcd(gcd(i, j), y);

            }

        }

    }

    co(ans);



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7330266286408615x):
#include <iostream>

#include <algorithm>

#include <iomanip>

#include <string>

#include <string.h>

#include <vector>

#include <math.h>

#include <queue>

#include <map>

#define INF 100000000



const int MOD = 1e9+7;

typedef long long ll;

using namespace std;

const ll M = 998244353;



ll gcd(ll a, ll b) {

    ll tmp, r;

    if(a<b) {

        tmp = a;

        a = b;

        b = tmp;

    }



    r = a%b;

    while(r!=0) {

        a = b;

        b = r;

        r = a%b;

    }



    return b;

}



int main(void) {

	ll k, sum=0;

	cin >> k;

	for(ll a=1;a<k+1;a++) {

	  for(ll b=1;b<k+1;b++) {

		for(ll c=1;c<k+1;c++) {

          sum += gcd(gcd(a,b), c);

		}

	  }	

	}



	cout << sum << endl;

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

using namespace std;



int gcd(int p,int q)

{

    if(q==0) return p;

    return gcd(q,p%q);

}



int main(void)

{

    int k,sum=0,g;

    cin >> k;

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

    {

        for(int j=1;j<=k;j++)

        {

            g = gcd(i,j);

            for(int l=1;l<=k;l++)

            {

                sum+=gcd(g,l);

            }

        }

    }

    cout << sum;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.2959343238800622x):
#include<cstdio>

int e(int p,int q)

{

    if(q==0)

        return p;

    return e(q,p%q);

}

int main(void)

{

    int k,sum=0;

    scanf("%d" ,&k);

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

        for(int j=1;j<=k;j++)

        {

            int g=e(i,j);

            for(int l=1;l<=k;l++)

                sum+=e(g,l);

        }

    printf("%d" ,sum);

    return 0;

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

using namespace std;



#define ll long long



int main()

{

    ll n,a,b;

    cin>>n;

    if(n==1)

        cout<<"Hello World"<<endl;

    else{

        cin>>a>>b;

        cout<<a+b<<endl;

    }

}


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



int main()

{

    int n,a,b;

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



    if(n==1)

        printf("Hello World\n");

    if(n==2)

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

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



using namespace std;

int main()

{

    int X,J,K,sum;

    scanf("%d",&X);

    if(X==1)

    {

        printf("Hello World");

    }

    else if(X==2)

    {

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

        sum=J+K;

        printf("%d",sum);

      

    }





}


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



int main()

{

    int n,a,b;

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



    if(n==1)

        printf("Hello World\n");

    if(n==2)

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

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

using namespace std;

int main(){

   int n;

   cin>>n;

   if(n==1){

    cout<<"Hello World"<<endl;

   }

   else if(n==2){

    int a,b;

    cin>>a>>b;

    cout<<a+b<<endl;

   }

}


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



int main()

{

    int n,a,b;

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



    if(n==1)

        printf("Hello World\n");

    if(n==2)

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

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

using namespace std;

int main()

{

    int n,a,b;

    cin>>n;

    if(n==1)

      cout<<"Hello World"<<endl;

    if(n==2)

    {

        cin>>a>>b;

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

    }

}


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



int main()

{

    int x, a, b;

    scanf("%d", &x);

    if(x==1)

    {

        printf("Hello World");

    }

    else

    {

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

        printf("%d", a+b);

    }

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

#include <algorithm>

#include <string>

#include <vector>

#include <set>

#include <cmath>

#include <stdio.h>

#include <list>

#include <numeric>

#include <stack>

#include <queue>

#include <tuple>

#include <bitset>

#include <map>

#include <math.h>

//　ceil(a/b)   (a + (b - 1))/ b

using namespace std;

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

typedef long long ll;

typedef pair<int,int> P;

const int inf = 1012345678;

int dx[] = {1,-1,0,0};

int dy[] = {0,0,1,-1};



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

//   if (a%b==0){

//     return(b);

//   }

//   else{

//     return(gcd(b,a%b));

//   }

// }





vector<int> v[100001];

int c[100000];

int y[100000];



int main(){

  int n;

  cin >> n;

  if(n == 1) cout << "Hello World" << endl;

  else {

    int a, b;

    cin >> a >> b;

    cout << a+b << endl;

  }

}




// Faster C++ solution for the same problem (measured speedup: 3.5362161999423685x):
#include <algorithm>

#include <bitset>

#include <cmath>

#include <ctime>

#include <iostream>

#include <list>

#include <map>

#include <math.h>

#include <numeric>

#include <queue>

#include <set>

#include <stack>

#include <stdio.h>

#include <string>

#include <tuple>

#include <vector>

using namespace std;

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

#define all(a) begin(a),end(a)

typedef long long ll;

typedef pair<int,int> P;

const int inf=1e+9;

const ll mod=1000000007;

const double PI=3.14159265358979323846;

int dx[] = {1,-1,0,0};

int dy[] = {0,0,1,-1};

ll gcd(ll a, ll b){

  if (b==0) return a;

  else return gcd(b,a%b);

}

int cans(bool f){

  if(f) cout << "Yes" << endl;

  else cout << "No" << endl;

  return 0;

}













int main() {

  int N;

  cin >> N;

  if(N==1) cout << "Hello World" << endl;

  else {

    int a,b;

    cin >> a >> b;

    cout << a + b << endl;

  }

  return 0;

}