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

using namespace std;

int main() {

    int kid;

    cin >> kid;

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

    return 0;

}

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



int main() {

  int N;

  scanf("%d", &N);

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

  return 0;

}



// Reading Material

// https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
// Slower C++ solution:
#include <iostream>

using namespace std;

int main() {

    int kid;

    cin >> kid;

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

    return 0;

}

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



int main() {

  int N;

  scanf("%d", &N);

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

  return 0;

}



// Reading Material

// https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<cstring>

using namespace std;

int main()

{

	int n,sum;

	while(scanf("%d",&n)!=EOF)

	{

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

//		{

//			sum+=i;

//		}	

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

		cout<<sum<<endl;

	}

	return 0;

	

 } 

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



int main() {

  int N;

  scanf("%d", &N);

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

  return 0;

}



// Reading Material

// https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

	long long ans;

	cin>>ans;

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

 } 

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



int main() {

  int N;

  scanf("%d", &N);

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

  return 0;

}



// Reading Material

// https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
// Slower C++ solution:
#include <iostream>

using namespace std;

int main()

{

    int N;

    cin>>N;

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

}

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



int main() {

  int N;

  scanf("%d", &N);

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

  return 0;

}



// Reading Material

// https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
// Slower C++ solution:
#include<bits/stdc++.h>



using namespace std;

#define REPP(i,a,b,c) for(int i=a; i<=b; i+=c)

#define REP(i,a,b) REPP(i,a,b,1)

#define REVV(i,a,b,c) for(int i=a; i>=b; i-=c)

#define REV(i,a,b) REVV(i,a,b,1)

#define FOR(i,a) REP(i,0,(int)a-1)

#define FORD(i,a) REV(i,(int)a-1,0)

#define PB push_back

#define POB pop_back

#define FI first

#define SE second

#define MP make_pair

typedef long long ll;

typedef unsigned long long ull;

typedef pair < int , int > pii;

typedef vector < int > vi;

typedef vector < pii > vii;

typedef vector < ll > vl;

typedef pair < ll , ll > pll;



const double PI = acos(-1);

const double EPS = 1e-9;

const ll MOD = 1e9 + 7;

const int INF = 1e9;

	



ll addMod(ll a, ll b){

	if(a + b >= MOD) return a + b - MOD;

	return a + b;

}



ll mulMod(ll a, ll b){

	return (a*b)%MOD;

}



ll fast(ll a, ll b){

	if(b == 0) return 1;

	ll tmp = fast(a,b/2);

	tmp = mulMod(tmp,tmp);

	if(b%2 == 1) tmp = mulMod(tmp,a);

	return tmp;

}



ll GCD(ll a, ll b){

	if(a > b) return GCD(b,a);

	if(a == 0) return b;

	return GCD(b%a,a);

}



//////////////////////////////////////////////







int main(){

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

	int n;

	cin >> n;

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

	return 0;

}

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



int main() {

  int N;

  scanf("%d", &N);

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

  return 0;

}



// Reading Material

// https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{

    int a;

    cin>>a;

    int sum;

    if(a==1)

    {

        sum=a;

    }

    else

    {

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



    }

    cout<<sum<<endl;

return 0;

}


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



int main() {

  int N;

  scanf("%d", &N);

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

  return 0;

}



// Reading Material

// https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
// Slower C++ solution:
////////////////////////// Author

////////////////////////// Nasim Hossain Rabbi

////////////////////////// JU-CSE28

////////////////////////// CF - imnasim3.1415

////////////////////////// UVA - imnasim3.1415

////////////////////////// Mail - imnasim3.1415@gmail.com

#include<bits/stdc++.h>

using namespace std;

#define E end()

#define B begin()

#define sz size()

#define EM empty()

#define fi first

#define se second

#define cl clear()

#define sqr(a) (a*a)

#define mk make_pair

#define pb push_back

string en="\n";

string sp=" ";

string t="hello";

string Y="YES\n";

string N="NO\n";

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

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

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

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

#define mem(a,b) memset(a,b,sizeof(a))

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

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL)

#define pi 3.1415926535897932384626433832795

#define vi vector<long long>

#define vs  vector<string>

#define MX LLONG_MAX

#define MN LLONG_MIN

#define MOD 1000000007

#define vp(vi,x) cin>>x; vi.pb(x);

#define bsearch(a,x) binary_search(all(a),x)

#define LB(a,x) (lower_bound(all(a),x)-a.B)

#define UB(a,x) (upper_bound(all(a),x)-a.B)

typedef long long LL;

typedef long double LD;

typedef unsigned long long ULL;

bool isprm(LL a){for(LL i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}

bool palin(string a){for(int i=0;i<a.sz;i++){if(a.at(i)!=a.at(a.sz-i-1))return 0;} return 1;}

bool isVowel(char ch){ ch=toupper(ch); if(ch=='A'||ch=='U'||ch=='I'||ch=='O'||ch=='E') return true; return false;}

int toInt(string s){int sm;stringstream ss(s);ss>>sm;return sm;}

LL bpow(LL a,LL b){if(b==0)return 1;LL r=bpow(a,b/2);if(b%2)return r*r*a;else return r*r;}

LL binpow(LL a,LL b){LL r=1;while(b>0){if(b&1)r=r*a;a=a*a;b>>=1;}return r;}

LL binpow(LL a,LL b,LL m){a%=m;LL r=1;while(b>0){if(b&1) r=r*a%m;a=a*a%m; b>>=1;}return r;}

template<typename T>inline T gcd(T a,T b){if(a<0)return gcd(-a,b);if(b<0)return gcd(a,-b);return (b==0)?a:gcd(b,a%b);}

template<typename T>inline T lcm(T a,T b) {if(a<0)return lcm(-a,b);if(b<0)return lcm(a,-b);return a*(b/gcd(a,b));}

int main()

{

//    fast;

    LL i,j,k,n,m,l,s=0,x,y,tc=1,p,q,a,b,c=0;

    bool f=0,ff=0;

    string st;

    while(cin>>n)

    {

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

        cout<<n<<en;

    }

}






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



int main() {

  int N;

  scanf("%d", &N);

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

  return 0;

}



// Reading Material

// https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
// Slower C++ solution:
//#define LOCAL 

#include <cstdio>

#include <iostream>

#include <vector>

#include <queue>

#include <list>

#include <cmath>

#include <string>

#include <cstring>

#include <algorithm>

using namespace std;



int main()

{

#ifdef LOCAL

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

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

#endif

	

	int n;

	cin >> n;

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

		

	return 0;

}

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

using namespace std;



int main()

{

	long long ans=0;

	int n;

	cin>>n;

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

	cout<<ans<<endl;

	return 0;

 } 

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

using namespace std;



int main()

{

	long long a;

	while(cin>>a)

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

	return 0;

}

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

using namespace std;

 

int n;

 

int main(){

	cin >> n;

	

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

	return 0;

}

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

using namespace std;

int main() {

    int kid;

    cin >> kid;

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

    return 0;

}

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

using namespace std;

int main() {

    int kid;

    cin >> kid;

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

    return 0;

}

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

#include<cstdio>

#include<cstring>

using namespace std;

int main()

{

	int n,sum;

	while(scanf("%d",&n)!=EOF)

	{

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

//		{

//			sum+=i;

//		}	

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

		cout<<sum<<endl;

	}

	return 0;

	

 } 

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

using namespace std;

int main()

{

	long long ans;

	cin>>ans;

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

 } 

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

int main()

{

    int a;

    scanf("%d",&a);

    int 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*(N+1)/2;

}

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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



using namespace std;

#define REPP(i,a,b,c) for(int i=a; i<=b; i+=c)

#define REP(i,a,b) REPP(i,a,b,1)

#define REVV(i,a,b,c) for(int i=a; i>=b; i-=c)

#define REV(i,a,b) REVV(i,a,b,1)

#define FOR(i,a) REP(i,0,(int)a-1)

#define FORD(i,a) REV(i,(int)a-1,0)

#define PB push_back

#define POB pop_back

#define FI first

#define SE second

#define MP make_pair

typedef long long ll;

typedef unsigned long long ull;

typedef pair < int , int > pii;

typedef vector < int > vi;

typedef vector < pii > vii;

typedef vector < ll > vl;

typedef pair < ll , ll > pll;



const double PI = acos(-1);

const double EPS = 1e-9;

const ll MOD = 1e9 + 7;

const int INF = 1e9;

	



ll addMod(ll a, ll b){

	if(a + b >= MOD) return a + b - MOD;

	return a + b;

}



ll mulMod(ll a, ll b){

	return (a*b)%MOD;

}



ll fast(ll a, ll b){

	if(b == 0) return 1;

	ll tmp = fast(a,b/2);

	tmp = mulMod(tmp,tmp);

	if(b%2 == 1) tmp = mulMod(tmp,a);

	return tmp;

}



ll GCD(ll a, ll b){

	if(a > b) return GCD(b,a);

	if(a == 0) return b;

	return GCD(b%a,a);

}



//////////////////////////////////////////////







int main(){

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

	int n;

	cin >> n;

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

	return 0;

}

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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

using namespace std;

int main()

{

    int a;

    cin>>a;

    int sum;

    if(a==1)

    {

        sum=a;

    }

    else

    {

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



    }

    cout<<sum<<endl;

return 0;

}


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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

}
// Slower C++ solution:
////////////////////////// Author

////////////////////////// Nasim Hossain Rabbi

////////////////////////// JU-CSE28

////////////////////////// CF - imnasim3.1415

////////////////////////// UVA - imnasim3.1415

////////////////////////// Mail - imnasim3.1415@gmail.com

#include<bits/stdc++.h>

using namespace std;

#define E end()

#define B begin()

#define sz size()

#define EM empty()

#define fi first

#define se second

#define cl clear()

#define sqr(a) (a*a)

#define mk make_pair

#define pb push_back

string en="\n";

string sp=" ";

string t="hello";

string Y="YES\n";

string N="NO\n";

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

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

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

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

#define mem(a,b) memset(a,b,sizeof(a))

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

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL)

#define pi 3.1415926535897932384626433832795

#define vi vector<long long>

#define vs  vector<string>

#define MX LLONG_MAX

#define MN LLONG_MIN

#define MOD 1000000007

#define vp(vi,x) cin>>x; vi.pb(x);

#define bsearch(a,x) binary_search(all(a),x)

#define LB(a,x) (lower_bound(all(a),x)-a.B)

#define UB(a,x) (upper_bound(all(a),x)-a.B)

typedef long long LL;

typedef long double LD;

typedef unsigned long long ULL;

bool isprm(LL a){for(LL i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}

bool palin(string a){for(int i=0;i<a.sz;i++){if(a.at(i)!=a.at(a.sz-i-1))return 0;} return 1;}

bool isVowel(char ch){ ch=toupper(ch); if(ch=='A'||ch=='U'||ch=='I'||ch=='O'||ch=='E') return true; return false;}

int toInt(string s){int sm;stringstream ss(s);ss>>sm;return sm;}

LL bpow(LL a,LL b){if(b==0)return 1;LL r=bpow(a,b/2);if(b%2)return r*r*a;else return r*r;}

LL binpow(LL a,LL b){LL r=1;while(b>0){if(b&1)r=r*a;a=a*a;b>>=1;}return r;}

LL binpow(LL a,LL b,LL m){a%=m;LL r=1;while(b>0){if(b&1) r=r*a%m;a=a*a%m; b>>=1;}return r;}

template<typename T>inline T gcd(T a,T b){if(a<0)return gcd(-a,b);if(b<0)return gcd(a,-b);return (b==0)?a:gcd(b,a%b);}

template<typename T>inline T lcm(T a,T b) {if(a<0)return lcm(-a,b);if(b<0)return lcm(a,-b);return a*(b/gcd(a,b));}

int main()

{

//    fast;

    LL i,j,k,n,m,l,s=0,x,y,tc=1,p,q,a,b,c=0;

    bool f=0,ff=0;

    string st;

    while(cin>>n)

    {

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

        cout<<n<<en;

    }

}






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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

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

    scanf("%d",&a);

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

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

    return 0;

}
// Slower C++ solution:
//#define LOCAL 

#include <cstdio>

#include <iostream>

#include <vector>

#include <queue>

#include <list>

#include <cmath>

#include <string>

#include <cstring>

#include <algorithm>

using namespace std;



int main()

{

#ifdef LOCAL

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

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

#endif

	

	int n;

	cin >> n;

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

		

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.254488450211417x):
#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<bits/stdc++.h>

using namespace std;



int main()

{

	long long ans=0;

	int n;

	cin>>n;

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

	cout<<ans<<endl;

	return 0;

 } 

// Faster C++ solution for the same problem (measured speedup: 5.260696464053116x):
#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()

{

	long long a;

	while(cin>>a)

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

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.259498127925497x):
#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 n;

 

int main(){

	cin >> n;

	

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

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.263379465913437x):
#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 kid;

    cin >> kid;

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

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.263639683164822x):
#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 kid;

    cin >> kid;

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

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.254303837003629x):
#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>

#include<cstdio>

#include<cstring>

using namespace std;

int main()

{

	int n,sum;

	while(scanf("%d",&n)!=EOF)

	{

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

//		{

//			sum+=i;

//		}	

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

		cout<<sum<<endl;

	}

	return 0;

	

 } 

// Faster C++ solution for the same problem (measured speedup: 5.2610910098224934x):
#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()

{

	long long ans;

	cin>>ans;

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

 } 

// Faster C++ solution for the same problem (measured speedup: 5.250321646421852x):
#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*(N+1)/2;

}

// Faster C++ solution for the same problem (measured speedup: 5.254303837003629x):
#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<bits/stdc++.h>



using namespace std;

#define REPP(i,a,b,c) for(int i=a; i<=b; i+=c)

#define REP(i,a,b) REPP(i,a,b,1)

#define REVV(i,a,b,c) for(int i=a; i>=b; i-=c)

#define REV(i,a,b) REVV(i,a,b,1)

#define FOR(i,a) REP(i,0,(int)a-1)

#define FORD(i,a) REV(i,(int)a-1,0)

#define PB push_back

#define POB pop_back

#define FI first

#define SE second

#define MP make_pair

typedef long long ll;

typedef unsigned long long ull;

typedef pair < int , int > pii;

typedef vector < int > vi;

typedef vector < pii > vii;

typedef vector < ll > vl;

typedef pair < ll , ll > pll;



const double PI = acos(-1);

const double EPS = 1e-9;

const ll MOD = 1e9 + 7;

const int INF = 1e9;

	



ll addMod(ll a, ll b){

	if(a + b >= MOD) return a + b - MOD;

	return a + b;

}



ll mulMod(ll a, ll b){

	return (a*b)%MOD;

}



ll fast(ll a, ll b){

	if(b == 0) return 1;

	ll tmp = fast(a,b/2);

	tmp = mulMod(tmp,tmp);

	if(b%2 == 1) tmp = mulMod(tmp,a);

	return tmp;

}



ll GCD(ll a, ll b){

	if(a > b) return GCD(b,a);

	if(a == 0) return b;

	return GCD(b%a,a);

}



//////////////////////////////////////////////







int main(){

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

	int n;

	cin >> n;

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

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.3355063324157x):
#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 a;

    cin>>a;

    int sum;

    if(a==1)

    {

        sum=a;

    }

    else

    {

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



    }

    cout<<sum<<endl;

return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.263320727278329x):
#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:
////////////////////////// Author

////////////////////////// Nasim Hossain Rabbi

////////////////////////// JU-CSE28

////////////////////////// CF - imnasim3.1415

////////////////////////// UVA - imnasim3.1415

////////////////////////// Mail - imnasim3.1415@gmail.com

#include<bits/stdc++.h>

using namespace std;

#define E end()

#define B begin()

#define sz size()

#define EM empty()

#define fi first

#define se second

#define cl clear()

#define sqr(a) (a*a)

#define mk make_pair

#define pb push_back

string en="\n";

string sp=" ";

string t="hello";

string Y="YES\n";

string N="NO\n";

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

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

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

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

#define mem(a,b) memset(a,b,sizeof(a))

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

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL)

#define pi 3.1415926535897932384626433832795

#define vi vector<long long>

#define vs  vector<string>

#define MX LLONG_MAX

#define MN LLONG_MIN

#define MOD 1000000007

#define vp(vi,x) cin>>x; vi.pb(x);

#define bsearch(a,x) binary_search(all(a),x)

#define LB(a,x) (lower_bound(all(a),x)-a.B)

#define UB(a,x) (upper_bound(all(a),x)-a.B)

typedef long long LL;

typedef long double LD;

typedef unsigned long long ULL;

bool isprm(LL a){for(LL i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}

bool palin(string a){for(int i=0;i<a.sz;i++){if(a.at(i)!=a.at(a.sz-i-1))return 0;} return 1;}

bool isVowel(char ch){ ch=toupper(ch); if(ch=='A'||ch=='U'||ch=='I'||ch=='O'||ch=='E') return true; return false;}

int toInt(string s){int sm;stringstream ss(s);ss>>sm;return sm;}

LL bpow(LL a,LL b){if(b==0)return 1;LL r=bpow(a,b/2);if(b%2)return r*r*a;else return r*r;}

LL binpow(LL a,LL b){LL r=1;while(b>0){if(b&1)r=r*a;a=a*a;b>>=1;}return r;}

LL binpow(LL a,LL b,LL m){a%=m;LL r=1;while(b>0){if(b&1) r=r*a%m;a=a*a%m; b>>=1;}return r;}

template<typename T>inline T gcd(T a,T b){if(a<0)return gcd(-a,b);if(b<0)return gcd(a,-b);return (b==0)?a:gcd(b,a%b);}

template<typename T>inline T lcm(T a,T b) {if(a<0)return lcm(-a,b);if(b<0)return lcm(a,-b);return a*(b/gcd(a,b));}

int main()

{

//    fast;

    LL i,j,k,n,m,l,s=0,x,y,tc=1,p,q,a,b,c=0;

    bool f=0,ff=0;

    string st;

    while(cin>>n)

    {

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

        cout<<n<<en;

    }

}






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



int main()

{

    int a, b;



    scanf("%d", &a);



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



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



    return 0;

}