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

#include<string>

using namespace std;

int main()

{

    string s;

    string s2="2018";

    getline(cin,s);

    s.replace(0,4,s2);

    cout<<s<<endl;



}


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

int main(){

	char angka[100];

	scanf("%[^\n]" , angka);

	angka[3] = '8';

	printf("%s" , angka);

	

}

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

using  namespace std;

int main ()

{

    string a;

    cin>>a;

    a[3]='8';



    cout<<a<<endl;



}


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

int main(){

	char angka[100];

	scanf("%[^\n]" , angka);

	angka[3] = '8';

	printf("%s" , angka);

	

}

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

#include<iostream>

#include<cstdio>

#include<string.h>



int main()

{

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

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

    int a,b,c;

    char str[100];

    scanf("%s",str);

    int ln=strlen(str);

    printf("2018");

    for(int i=4;i<ln;i++){

        printf("%c",str[i]);

    }

    printf("\n");











    return 0;

}




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

int main(){

	char angka[100];

	scanf("%[^\n]" , angka);

	angka[3] = '8';

	printf("%s" , angka);

	

}

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

#define fi first

#define se second

#define pb push_back

using namespace std;

typedef long long LL;

typedef pair<int, int> pii;



int main()

{

    string S;

    cin>>S;

    S[3]='8';

    cout<<S<<endl;

    return 0;

}


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

int main(){

	char angka[100];

	scanf("%[^\n]" , angka);

	angka[3] = '8';

	printf("%s" , angka);

	

}

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



#include <bits/stdc++.h>

using namespace std;



//pragmas

/*

#pragma comment(linker, "/stack:200000000")

#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#pragma GCC target ("avx2")

#pragma GCC optimization ("Ofast")

#pragma GCC optimization ("unroll-loops")

*/



typedef pair<int, int> ii;

typedef vector<int> vi;

typedef vector<ii> vii;

typedef long long int ll;

typedef unsigned long long int ull;

typedef long double ld;



#define FOR(a,b,c) for(ll (a)=(b);(a)<(c);++(a))

#define FORE(a,b,c) for(ll (a)=(b);(a)<=(c);++(a))

#define FORN(a,b,c) for(ll (a)=(b);(a)>(c);--(a))

#define FORNE(a,b,c) for(ll (a)=(b);(a)>=(c);--(a))

#define COUT(a) cout << (a) << '\n'

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

#define MAX(a,b) (a) = max((a), (b))

#define MIN(a,b) (a) = min((a), (b))

#define nl '\n'

#define fi first

#define se second

#define mp make_pair

#define pb push_back

#define pi acos(-1.0)



void init(){

	ios_base::sync_with_stdio(false);

	cin.tie(NULL);

	cout.tie(NULL);

}



//End of template



int main(){

	init();



	//debug

	/*

	ifstream in("input.in");

	streambuf *cinbuf = std::cin.rdbuf();

	cin.rdbuf(in.rdbuf());



	ofstream out("out.txt");

	streambuf *coutbuf = std::cout.rdbuf();

	cout.rdbuf(out.rdbuf());

	*/

	//end debug



	string s;

	cin >> s;

	cout << "2018" << s.substr(4, s.length()) << nl;

	return 0;

}

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

int main(){

	char angka[100];

	scanf("%[^\n]" , angka);

	angka[3] = '8';

	printf("%s" , angka);

	

}

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

using namespace std;

int main(){

	string s;

	cin >> s;

	cout << 2018;

	for(int i = 4; i < s.size(); i++)cout<<s[i];

	

	

}

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



int main(){

	char r[255];

	scanf("%[^\n]", r);

	r[0] = '2';

	r[1] = '0';

	r[2] = '1';

	r[3] = '8';

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

	return 0;

	

}

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

#include<stdio.h>

using namespace std;

#define ll long long



int main()

{

	string s,r="2018";

	cin>>s;

	

	s.replace(0,4,r); 

	cout<<s;

	

	

		

	

}






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



int main(){

	char r[255];

	scanf("%[^\n]", r);

	r[0] = '2';

	r[1] = '0';

	r[2] = '1';

	r[3] = '8';

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

	return 0;

	

}

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

using namespace std;



int main() {

  int a, b, h, w;

	cin >> a >> b >> h >> w;

	cout << (a * b) - (h * b) - (w * (a - h));

}

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

 

int main()

{

    int H, W, h, w;

    H>0, W>0;

    H>=h, W>=w;

    scanf("%d %d", &H ,&W);

    scanf("%d %d", &h ,&w);

    printf("%d\n", (H-h)*(W-w));

 

    return 0;

 

}

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

using namespace std;



int H,W,h,w,x,y,z;

int main()

{

	

	cin >> H >> W;

	cin >> h >> w;

	

	x = H*W;

	y = h*W;

	z = (w*H)-(w*h);

	

	cout << (x-y-z) << endl;

	

	return 0;

}

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

 

int main()

{

    int H, W, h, w;

    H>0, W>0;

    H>=h, W>=w;

    scanf("%d %d", &H ,&W);

    scanf("%d %d", &h ,&w);

    printf("%d\n", (H-h)*(W-w));

 

    return 0;

 

}

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

using namespace std;

int main()

{

    int x,y,a,b;

    cin>>x>>y>>a>>b;

    int r=x-a;

    int m=(x*y)-(a*y)-(b*(x-a));

    cout<<m<<endl;

}




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

 

int main()

{

    int H, W, h, w;

    H>0, W>0;

    H>=h, W>=w;

    scanf("%d %d", &H ,&W);

    scanf("%d %d", &h ,&w);

    printf("%d\n", (H-h)*(W-w));

 

    return 0;

 

}

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

using namespace std;

int main()

{

   int n;

   cin>>n;

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

}


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



int main() {

	int N;

	int candy;

	

	scanf("%d", &N);

	candy = N*(N+1)/2;

	printf("%d", candy);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
///AJoy Sarker ,CSE JAHANGIRNAGAR UNIVERSITY 48 Batch

#include<bits/stdc++.h>

using namespace std;

#define SORT(c) sort((c).begin(),(c).end());

#define pb push_back

#define MP make_pair

#define pii pair<int,int>

#define pcc pair<char,char>

#define pic pair<int,char>

#define pci pair<char,int>

#define VS vector<string>

#define VI vector<int>

#define pi 3.141592653589793

#define ll long long

#define ull unsigned long long

#define w(x) int x;cin>>x;while(x--)

#define fast ios_base::sync_with_stdio(0)

#define sz size()

typedef unsigned long long UL;

template<typename T>inline T  S(T a)

{

    return a*a;

}

template<class T>inline string tostring(T a)

{

    ostringstream os("");

    os << a;

    return os.str();

}

template<typename T>inline ll tolong(T a)

{

    ll res;

    istringstream os(a);

    os>>res;

    return res;

}

template<typename T>inline T gcd(T a, T b)

{

    if (b == 0)return a;

    else return gcd(b, a % b);

}

template<typename T>inline T bigmod(T a, T b, T m)

{

    if (b == 0)return 1;

    else if (b % 2 == 0)return S(bigmod(a, b / 2, m)) % m;

    else return (a % m*bigmod(a, b - 1, m)) % m;

}

const int inf = (int)1e9 + 5;

const ll linf = (ll)1e16 + 5;

const ll modd = (ll)1e9 + 7;

const int mod = 10000007;

/*#define N 20000009

bool prime[N];

vector<ll> prm;

void seive ()

{



    memset(prime, true, sizeof(prime));



    for( ll i=2; i*i<=N; i++)

    {

        if (prime[i] == true)

        {

            prm.pb(i);

            for (ll j=i*i; j<=N; j += i)

                prime[j] = false;

        }

    }

}*/

void pr (int f)

{

    if(f==1)

        cout<<"YES\n";

    else

        cout<<"NO\n";

}

map<int,int>mp;

multiset<string> st;

multiset<string> :: iterator it;



deque <char> q ;

int vis [1000];

int main()

{

    fast ;

    ll n ;   

   cin >> n;

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

}










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



int main() {

	int N;

	int candy;

	

	scanf("%d", &N);

	candy = N*(N+1)/2;

	printf("%d", candy);

	

	return 0;

}

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

using namespace std;

int main(){

	

	int sum=0,n;

	cin>>n;

		

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

			cout<<sum;



	



	

}

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



int main() {

	int N;

	int candy;

	

	scanf("%d", &N);

	candy = N*(N+1)/2;

	printf("%d", candy);

	

	return 0;

}

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

using namespace std;

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef long double ld;

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

#define ceil(n, m) ((n / m) + ( n % m ? 1 : 0))

#define fast_IO  ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define file_in freopen("input.txt","r",stdin);

#define file_out freopen("output.txt","w",stdout);

#define file freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);



int main(){

    //fast_IO;

    

    int n;

    cin >> n;

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

    return 0;

}


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



int main() {

	int N;

	int candy;

	

	scanf("%d", &N);

	candy = N*(N+1)/2;

	printf("%d", candy);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
//#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;

}

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

int main(){

	int n;

	scanf("%d",&n);

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

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

 } 

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

int main(){

	int n;

	scanf("%d",&n);

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

}

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

using namespace std;



int main()

{

	long long a;

	while(cin>>a)

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

	return 0;

}

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

int main(){

	int n;

	scanf("%d",&n);

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

}

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

using namespace std;

 

int n;

 

int main(){

	cin >> n;

	

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

	return 0;

}

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

int main(){

	int n;

	scanf("%d",&n);

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

}

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

using namespace std;

int main() {

    int kid;

    cin >> kid;

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

    return 0;

}

// Optimized solution to the same problem (faster):
#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

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

using namespace std;

int main() {

    int kid;

    cin >> kid;

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

    return 0;

}

// Optimized solution to the same problem (faster):
#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

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

	

 } 

// Optimized solution to the same problem (faster):
#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

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

using namespace std;

int main()

{

	long long ans;

	cin>>ans;

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

 } 

// Optimized solution to the same problem (faster):
#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

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

using namespace std;

int main()

{

    int N;

    cin>>N;

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

}

// Optimized solution to the same problem (faster):
#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

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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

// Fastest known solution for this problem:
// Original C++ solution (slower):
////////////////////////// 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;

    }

}






// Optimized solution to the same problem (faster):
#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

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

using namespace std;

int main()

{

    int Num;

    cin>>Num;

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

}


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

int main()

{

    int a;

    scanf("%d",&a);

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

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

    return 0;

}


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



using namespace std;



int main()

{

	int N;



	cin >> N;

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

}

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



using namespace std;



int main()

{

	int n;



	scanf("%d", &n);

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

	

	return 0;

}

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



using namespace std;



int main(void) {

    int N;

    cin >> N;

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

    return 0;

}


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



using namespace std;



int main() {

    int N;

    scanf("%d", &N);



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

    return 0;

}


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

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;

}










// Optimized solution to the same problem (faster):
#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;

}


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

using namespace std;

int main(){

	int sum=0,n;

	cin>>n;

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

	cout<<sum;

	return 0;

}


// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem: