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

using namespace std;

int main()

{

    int Num;

    cin>>Num;

    cout<<(Num*(Num+1)/2)<<endl;

}


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



int main()

{

    int a, b;



    scanf("%d", &a);



    b = (a*(a+1))/2;



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



    return 0;

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



using namespace std;



int main()

{

	int N;



	cin >> N;

	cout << (N + 1)*N / 2 << endl;

}

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



using namespace std;



int main()

{

	int n;



	scanf("%d", &n);

	printf("%d\n", (n + 1)*n / 2);

	

	return 0;

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



using namespace std;



int main(void) {

    int N;

    cin >> N;

    cout << (N*(N+1))/2 << endl;

    return 0;

}


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



using namespace std;



int main() {

    int N;

    scanf("%d", &N);



    printf("%d\n", (N*(N+1))>>1);

    return 0;

}
// Slower C++ solution:
/**

DufauX-XuafuD

**/

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

typedef pair<long long, long long> pll;

#define ff first

#define ss second

#define mp make_pair

#define pb push_back

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

#define FastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);

#define reset(x) memset(x,-1,sizeof(x))

#define CheckBit(a,b) (a&(1ll<<b))

#define SetBit(a,b) a=(a|(1ll<<b))

#define UnSetBit(a,b) a=(a&(~(1ll<<b)))

#define maxx 10000006

#define PI 2*acos(0.0)

const long long INF = 2000000000000000000LL;	// 2e18

const int inf = 0x3f3f3f3f;	// 1061109567

const long double EPS = 1e-9;

//bitset<maxx/2>vis;

//bitset<maxx>pr;

//int mobi[maxx+10];

//vector<ll>prime;

//void sieve(){

//    ll x=maxx/2, y=sqrt(maxx)/2;

//    for(ll i=1;i<=y;i++){

//        if(vis[i]==0){

//            for(ll j=(i*(i+1)*2);j<x;j+=(2*i)+1)

//                vis[j]=1;

//        }

//    }

//    prime.push_back(2);

//    for(ll i=3;i<maxx;i+=2)

//        if(vis[i/2]==0)

//        prime.push_back(i);

//}

//void generate_mobius()

//{

//    for(int i=0;i<maxx;i++)mobi[i]=1;

//    for(int i=2;i<maxx;i++){

//        if(!pr[i]){

//            mobi[i]*=-1;

//            for(int j=i+i;j<maxx;j+=i){

//                pr[j]=1;

//                mobi[j]*=(j%(i*i)?-1:0);

//            }

//        }

//    }

//}

//bool isprime(ll a)

//{

//    if(a==1)return false;

//    if(a==2)return true;

//    if(a%2==0)return false;

//    for(ll i=0;i<prime.size() && prime[i]*prime[i]<=a;i++)

//        if(a%prime[i]==0)return false;

//    return true;

//}

/* Calculate ( a*b ) %c */

inline ll mulmod(ll a, ll b, ll c) {

    ll ret = 0 , cur = a % c ;

    while(b) { if(b%2) ret=(ret+cur)%c; cur=(cur<<1)%c; b=b>>1; }

    return ret%c;

}

//Calculate (b^p)%m || modular inverse: b^-1 = bigmod(b, m-2, m)

inline ll bigmod(ll b, ll p, ll m){

    ll ret = 1, cur = b % m;

    while(p) { if(p&1) ret=(ret*cur)%m; cur=(cur*cur)%m; p=p>>1; }

    return ret;

}

inline ll modulo(ll a,ll b,ll c) { //Same as big mod, use for numbers over 1e10

    ll ret = 1 , cur = a%c ;

    while(b) { if(b%2) ret=mulmod(ret,cur,c); cur=mulmod(cur,cur,c); b=b>>1; }

    return ret%c ;

}

inline ll power(ll b, ll p){

    ll ret = 1, cur = b;

    while(p) { if(p&1) ret=(ret*cur); cur=(cur*cur); p=p>>1; }

    return ret;

}

ll lcm(ll a,ll b)

{

    return (a/__gcd(a,b))*b;

}

ll gcd(ll a,ll b)

{

    return __gcd(a,b);

}

void Dufaux()

{

    ll n;

    cin>>n;

    cout<<(n*(n+1))/2<<endl;

}

int main()

{

    FastIO;

	///sieve();

	///generate_mobius();

	int test=1;

	while(test--){

        Dufaux();

	}

	return 0;

}










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

#include<math.h>

#include<stdlib.h>

#include<string.h>



#define size 100005



int main()

{

    int n, sum;

    scanf("%d", &n);

    sum = n*(n+1)/2;

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

    return 0;

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

using namespace std;

int main(){

	int sum=0,n;

	cin>>n;

	sum=n*(n+1)/2;

	cout<<sum;

	return 0;

}


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

#include<math.h>

#include<stdlib.h>

#include<string.h>



#define size 100005



int main()

{

    int n, sum;

    scanf("%d", &n);

    sum = n*(n+1)/2;

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

    return 0;

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

using namespace std;

const int N=101;



string arr[N];

int solve()

{

    long long n;

    cin>>n;

    cout<<n*(n+1)/2;

    return 0;

}



int main()

{

#ifndef ONLINE_JUDGE

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

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

#endif

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);



   // int t;

   // cin>>t;

   // while(t--)

        solve();



    return 0;

}

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

#include<math.h>

#include<stdlib.h>

#include<string.h>



#define size 100005



int main()

{

    int n, sum;

    scanf("%d", &n);

    sum = n*(n+1)/2;

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

    return 0;

}
// Slower C++ solution:
/**

DufauX-XuafuD

**/

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

typedef pair<long long, long long> pll;

#define ff first

#define ss second

#define mp make_pair

#define pb push_back

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

#define FastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);

#define reset(x) memset(x,-1,sizeof(x))

#define CheckBit(a,b) (a&(1ll<<b))

#define SetBit(a,b) a=(a|(1ll<<b))

#define UnSetBit(a,b) a=(a&(~(1ll<<b)))

#define maxx 10000006

#define PI 2*acos(0.0)

const long long INF = 2000000000000000000LL;	// 2e18

const int inf = 0x3f3f3f3f;	// 1061109567

const long double EPS = 1e-9;

//bitset<maxx/2>vis;

//bitset<maxx>pr;

//int mobi[maxx+10];

//vector<ll>prime;

//void sieve(){

//    ll x=maxx/2, y=sqrt(maxx)/2;

//    for(ll i=1;i<=y;i++){

//        if(vis[i]==0){

//            for(ll j=(i*(i+1)*2);j<x;j+=(2*i)+1)

//                vis[j]=1;

//        }

//    }

//    prime.push_back(2);

//    for(ll i=3;i<maxx;i+=2)

//        if(vis[i/2]==0)

//        prime.push_back(i);

//}

//void generate_mobius()

//{

//    for(int i=0;i<maxx;i++)mobi[i]=1;

//    for(int i=2;i<maxx;i++){

//        if(!pr[i]){

//            mobi[i]*=-1;

//            for(int j=i+i;j<maxx;j+=i){

//                pr[j]=1;

//                mobi[j]*=(j%(i*i)?-1:0);

//            }

//        }

//    }

//}

//bool isprime(ll a)

//{

//    if(a==1)return false;

//    if(a==2)return true;

//    if(a%2==0)return false;

//    for(ll i=0;i<prime.size() && prime[i]*prime[i]<=a;i++)

//        if(a%prime[i]==0)return false;

//    return true;

//}

/* Calculate ( a*b ) %c */

inline ll mulmod(ll a, ll b, ll c) {

    ll ret = 0 , cur = a % c ;

    while(b) { if(b%2) ret=(ret+cur)%c; cur=(cur<<1)%c; b=b>>1; }

    return ret%c;

}

//Calculate (b^p)%m || modular inverse: b^-1 = bigmod(b, m-2, m)

inline ll bigmod(ll b, ll p, ll m){

    ll ret = 1, cur = b % m;

    while(p) { if(p&1) ret=(ret*cur)%m; cur=(cur*cur)%m; p=p>>1; }

    return ret;

}

inline ll modulo(ll a,ll b,ll c) { //Same as big mod, use for numbers over 1e10

    ll ret = 1 , cur = a%c ;

    while(b) { if(b%2) ret=mulmod(ret,cur,c); cur=mulmod(cur,cur,c); b=b>>1; }

    return ret%c ;

}

inline ll power(ll b, ll p){

    ll ret = 1, cur = b;

    while(p) { if(p&1) ret=(ret*cur); cur=(cur*cur); p=p>>1; }

    return ret;

}

ll lcm(ll a,ll b)

{

    return (a/__gcd(a,b))*b;

}

ll gcd(ll a,ll b)

{

    return __gcd(a,b);

}

void Dufaux()

{

    ll n;

    cin>>n;

    cout<<(n*(n+1))/2<<endl;

}

int main()

{

    FastIO;

	///sieve();

	///generate_mobius();

	int test=1;

	while(test--){

        Dufaux();

	}

	return 0;

}










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

int main()

{

    int n,s,i;

    scanf("%d", &n);

    s=(n*(n+1))/2;

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



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

using namespace std;

int main(){

	int sum=0,n;

	cin>>n;

	sum=n*(n+1)/2;

	cout<<sum;

	return 0;

}


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

int main()

{

    int n,s,i;

    scanf("%d", &n);

    s=(n*(n+1))/2;

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



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

using namespace std;

const int N=101;



string arr[N];

int solve()

{

    long long n;

    cin>>n;

    cout<<n*(n+1)/2;

    return 0;

}



int main()

{

#ifndef ONLINE_JUDGE

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

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

#endif

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);



   // int t;

   // cin>>t;

   // while(t--)

        solve();



    return 0;

}

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

int main()

{

    int n,s,i;

    scanf("%d", &n);

    s=(n*(n+1))/2;

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



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



using namespace std;



#define fst(t) std::get<0>(t)

#define snd(t) std::get<1>(t)

#define thd(t) std::get<2>(t)



using P = std::tuple<int,int>;

using ll = long long;



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



int main(){

    //*

    std::cin.tie(nullptr);

    std::ios::sync_with_stdio(false);

    /*/

      /*/



    int N;

    cin >> N;



    std::cout << N * (N+1) / 2 << std::endl;

}


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



int main(){

  int n;

  scanf("%d", &n);



  printf("%d\n", n * (n+1) / 2);

}
// Slower C++ solution:


#include<bits/stdc++.h>

#define lln long long int

#define llu unsigned lln

#define sc(n) scanf("%d",&n);

#define scl(n) scanf("%lld",&n);

#define scd(n) scanf("%lf",&n);

#define pf(res) printf("%d\n",res);

#define pfl(res) printf("%lld\n",res);

#define pfd(res) printf("%lf\n",res);

#define maxii 100005

using namespace std;

typedef pair<int,int> pii;

typedef pair<lln,lln> pll;

 vector<int> vi[maxii];

 vector<int>:: iterator child;

typedef vector<lln> vl;

typedef vector<pii> vii;

typedef vector<pll> vll;





int arr[maxii];

int arr2[maxii];

bool check[maxii];



bool dfs(int node,int c)

{

    check[node]=true;

    arr2[node]=c;

    for(int child=0;child<vi[node].size();child++)

    {

        if(check[vi[node][child]]==false)

        {

            if(dfs(vi[node][child],c^1)==false)

            {

                return false;

            }

        }

        else if(arr2[node]==arr2[vi[node][child]])

        {

            return false;

        }

        //else if()

    }

    return true;

}



int main()

{

    int n;

    cin>>n;

    int res=n*(n+1);

    res/=2;

    cout<<res;



}










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

using namespace std;

int main(){

	

	long long sum=0,n;

	cin>>n;

		

			sum= n*(n+1)/2;

			cout<<sum;



	



	

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

#include <cstdio>

#include <vector>

#include <iostream>

#include <algorithm>

#define LL long long

using namespace std;

const int MAXN = 2e5+55;

int vis[MAXN];

int main()

{

   int n;

   cin>>n;

   cout<<1ll*n*(n+1)/2;

    return 0;

}


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

int main (){

	

	int n;

	

	scanf("%d" , &n);	

	printf("%d\n" , n * (n+1) / 2);

	

	return 0;

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

#include <iostream>

#include <cstdio>

#include <cmath>

#include <cstring>

#include <cctype>

#include <queue>

#include <map>

#include <string>

#include <vector>

#include <set>

#include <math.h>

#include <stack>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <time.h>

#define ll long long

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

using namespace std;

const int MAXX = 100000 + 10;

const double PI = 3.14159265358979323846;

const ll mod = 1000000007;

int main() {

	int a, b, c;

	while (cin >> a) {

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

	}

	return 0;

}

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

int main (){

	

	int n;

	

	scanf("%d" , &n);	

	printf("%d\n" , n * (n+1) / 2);

	

	return 0;

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

using namespace std;

int main()

{

    long long int n;

    cin>>n;

    cout<<(n*(n+1))/2<<endl;

    return 0;

}




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

int main (){

	

	int n;

	

	scanf("%d" , &n);	

	printf("%d\n" , n * (n+1) / 2);

	

	return 0;

}
// Slower C++ solution:


#include<bits/stdc++.h>

#define lln long long int

#define llu unsigned lln

#define sc(n) scanf("%d",&n);

#define scl(n) scanf("%lld",&n);

#define scd(n) scanf("%lf",&n);

#define pf(res) printf("%d\n",res);

#define pfl(res) printf("%lld\n",res);

#define pfd(res) printf("%lf\n",res);

#define maxii 100005

using namespace std;

typedef pair<int,int> pii;

typedef pair<lln,lln> pll;

 vector<int> vi[maxii];

 vector<int>:: iterator child;

typedef vector<lln> vl;

typedef vector<pii> vii;

typedef vector<pll> vll;





int arr[maxii];

int arr2[maxii];

bool check[maxii];



bool dfs(int node,int c)

{

    check[node]=true;

    arr2[node]=c;

    for(int child=0;child<vi[node].size();child++)

    {

        if(check[vi[node][child]]==false)

        {

            if(dfs(vi[node][child],c^1)==false)

            {

                return false;

            }

        }

        else if(arr2[node]==arr2[vi[node][child]])

        {

            return false;

        }

        //else if()

    }

    return true;

}



int main()

{

    int n;

    cin>>n;

    int res=n*(n+1);

    res/=2;

    cout<<res;



}










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

int main (){

	

	int n;

	

	scanf("%d" , &n);	

	printf("%d\n" , n * (n+1) / 2);

	

	return 0;

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

using namespace std;

int main(){

	

	long long sum=0,n;

	cin>>n;

		

			sum= n*(n+1)/2;

			cout<<sum;



	



	

}

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

int main (){

	

	int n;

	

	scanf("%d" , &n);	

	printf("%d\n" , n * (n+1) / 2);

	

	return 0;

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

#include <cstdio>

#include <vector>

#include <iostream>

#include <algorithm>

#define LL long long

using namespace std;

const int MAXN = 2e5+55;

int vis[MAXN];

int main()

{

   int n;

   cin>>n;

   cout<<1ll*n*(n+1)/2;

    return 0;

}


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

int main (){

	int k,p;

	scanf ("%d", &k); 

	 

	// k = kids, p=permen;

	p= (k*(k+1)/2);

	printf ("%d", p);



return 0; 

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

#include <iostream>

#include <cstdio>

#include <cmath>

#include <cstring>

#include <cctype>

#include <queue>

#include <map>

#include <string>

#include <vector>

#include <set>

#include <math.h>

#include <stack>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <time.h>

#define ll long long

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

using namespace std;

const int MAXX = 100000 + 10;

const double PI = 3.14159265358979323846;

const ll mod = 1000000007;

int main() {

	int a, b, c;

	while (cin >> a) {

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

	}

	return 0;

}

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

int main (){

	int k,p;

	scanf ("%d", &k); 

	 

	// k = kids, p=permen;

	p= (k*(k+1)/2);

	printf ("%d", p);



return 0; 

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

using namespace std;

int main()

{

    long long int n;

    cin>>n;

    cout<<(n*(n+1))/2<<endl;

    return 0;

}




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

int main (){

	int k,p;

	scanf ("%d", &k); 

	 

	// k = kids, p=permen;

	p= (k*(k+1)/2);

	printf ("%d", p);



return 0; 

}
// Slower C++ solution:


#include<bits/stdc++.h>

#define lln long long int

#define llu unsigned lln

#define sc(n) scanf("%d",&n);

#define scl(n) scanf("%lld",&n);

#define scd(n) scanf("%lf",&n);

#define pf(res) printf("%d\n",res);

#define pfl(res) printf("%lld\n",res);

#define pfd(res) printf("%lf\n",res);

#define maxii 100005

using namespace std;

typedef pair<int,int> pii;

typedef pair<lln,lln> pll;

 vector<int> vi[maxii];

 vector<int>:: iterator child;

typedef vector<lln> vl;

typedef vector<pii> vii;

typedef vector<pll> vll;





int arr[maxii];

int arr2[maxii];

bool check[maxii];



bool dfs(int node,int c)

{

    check[node]=true;

    arr2[node]=c;

    for(int child=0;child<vi[node].size();child++)

    {

        if(check[vi[node][child]]==false)

        {

            if(dfs(vi[node][child],c^1)==false)

            {

                return false;

            }

        }

        else if(arr2[node]==arr2[vi[node][child]])

        {

            return false;

        }

        //else if()

    }

    return true;

}



int main()

{

    int n;

    cin>>n;

    int res=n*(n+1);

    res/=2;

    cout<<res;



}










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

int main (){

	int k,p;

	scanf ("%d", &k); 

	 

	// k = kids, p=permen;

	p= (k*(k+1)/2);

	printf ("%d", p);



return 0; 

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

using namespace std;

int main(){

	

	long long sum=0,n;

	cin>>n;

		

			sum= n*(n+1)/2;

			cout<<sum;



	



	

}

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

int main (){

	int k,p;

	scanf ("%d", &k); 

	 

	// k = kids, p=permen;

	p= (k*(k+1)/2);

	printf ("%d", p);



return 0; 

}
// Slower C++ solution:


#include<bits/stdc++.h>

#define lln long long int

#define llu unsigned lln

#define sc(n) scanf("%d",&n);

#define scl(n) scanf("%lld",&n);

#define scd(n) scanf("%lf",&n);

#define pf(res) printf("%d\n",res);

#define pfl(res) printf("%lld\n",res);

#define pfd(res) printf("%lf\n",res);

#define maxii 100005

using namespace std;

typedef pair<int,int> pii;

typedef pair<lln,lln> pll;

 vector<int> vi[maxii];

 vector<int>:: iterator child;

typedef vector<lln> vl;

typedef vector<pii> vii;

typedef vector<pll> vll;





int arr[maxii];

int arr2[maxii];

bool check[maxii];



bool dfs(int node,int c)

{

    check[node]=true;

    arr2[node]=c;

    for(int child=0;child<vi[node].size();child++)

    {

        if(check[vi[node][child]]==false)

        {

            if(dfs(vi[node][child],c^1)==false)

            {

                return false;

            }

        }

        else if(arr2[node]==arr2[vi[node][child]])

        {

            return false;

        }

        //else if()

    }

    return true;

}



int main()

{

    int n;

    cin>>n;

    int res=n*(n+1);

    res/=2;

    cout<<res;



}










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

#include<algorithm>

using namespace std;

int main()

{

    int n;

    cin>>n;

    cout<<(n*(1+n))/2;

    return 0;

}
// Slower C++ solution:


#include<bits/stdc++.h>

#define lln long long int

#define llu unsigned lln

#define sc(n) scanf("%d",&n);

#define scl(n) scanf("%lld",&n);

#define scd(n) scanf("%lf",&n);

#define pf(res) printf("%d\n",res);

#define pfl(res) printf("%lld\n",res);

#define pfd(res) printf("%lf\n",res);

#define maxii 100005

using namespace std;

typedef pair<int,int> pii;

typedef pair<lln,lln> pll;

 vector<int> vi[maxii];

 vector<int>:: iterator child;

typedef vector<lln> vl;

typedef vector<pii> vii;

typedef vector<pll> vll;





int arr[maxii];

int arr2[maxii];

bool check[maxii];



bool dfs(int node,int c)

{

    check[node]=true;

    arr2[node]=c;

    for(int child=0;child<vi[node].size();child++)

    {

        if(check[vi[node][child]]==false)

        {

            if(dfs(vi[node][child],c^1)==false)

            {

                return false;

            }

        }

        else if(arr2[node]==arr2[vi[node][child]])

        {

            return false;

        }

        //else if()

    }

    return true;

}



int main()

{

    int n;

    cin>>n;

    int res=n*(n+1);

    res/=2;

    cout<<res;



}










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

#include <algorithm>

using namespace std;

int main(){

	

	int n;

	cin>>n;

	cout<<n*(n+1)/2<<"\n";

	

	return 0;

	}
// Slower C++ solution:


#include<bits/stdc++.h>

#define lln long long int

#define llu unsigned lln

#define sc(n) scanf("%d",&n);

#define scl(n) scanf("%lld",&n);

#define scd(n) scanf("%lf",&n);

#define pf(res) printf("%d\n",res);

#define pfl(res) printf("%lld\n",res);

#define pfd(res) printf("%lf\n",res);

#define maxii 100005

using namespace std;

typedef pair<int,int> pii;

typedef pair<lln,lln> pll;

 vector<int> vi[maxii];

 vector<int>:: iterator child;

typedef vector<lln> vl;

typedef vector<pii> vii;

typedef vector<pll> vll;





int arr[maxii];

int arr2[maxii];

bool check[maxii];



bool dfs(int node,int c)

{

    check[node]=true;

    arr2[node]=c;

    for(int child=0;child<vi[node].size();child++)

    {

        if(check[vi[node][child]]==false)

        {

            if(dfs(vi[node][child],c^1)==false)

            {

                return false;

            }

        }

        else if(arr2[node]==arr2[vi[node][child]])

        {

            return false;

        }

        //else if()

    }

    return true;

}



int main()

{

    int n;

    cin>>n;

    int res=n*(n+1);

    res/=2;

    cout<<res;



}










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

#include <vector>

#include <algorithm>

#include <climits>

using namespace std ;



int main(){

    std::ios_base::sync_with_stdio(0);  cin.tie(NULL);  cout.tie(NULL);

    long long  n ;

    cin >> n ;

    cout << n * (n + 1 ) / 2 ;

    return 0 ;

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

#include <cstdio>

#include <vector>

#include <iostream>

#include <algorithm>

#define LL long long

using namespace std;

const int MAXN = 2e5+55;

int vis[MAXN];

int main()

{

   int n;

   cin>>n;

   cout<<1ll*n*(n+1)/2;

    return 0;

}


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



int main() {

  int n;

  scanf("%d", &n);

  printf("%d\n", n*(n + 1)/2);

  return 0;

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

#include <iostream>

#include <cstdio>

#include <cmath>

#include <cstring>

#include <cctype>

#include <queue>

#include <map>

#include <string>

#include <vector>

#include <set>

#include <math.h>

#include <stack>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <time.h>

#define ll long long

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

using namespace std;

const int MAXX = 100000 + 10;

const double PI = 3.14159265358979323846;

const ll mod = 1000000007;

int main() {

	int a, b, c;

	while (cin >> a) {

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

	}

	return 0;

}

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



int main() {

  int n;

  scanf("%d", &n);

  printf("%d\n", n*(n + 1)/2);

  return 0;

}