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

#include <cstdio>



using namespace std;



#define MAXN 203

int main(){

    char S[MAXN],T[MAXN];

    scanf("%s %s",S,T);

    printf("%s%s",T,S);

    return 0;

}


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

int main() {

	

	char character1[100];

	char character2[100];

	

	scanf("%s", character1);

	scanf("%s", character2);

	printf("%s%s", character2, character1);

	

	return 0;

}

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

#include<iostream>

using namespace std;

int main(void){



    

    string s1,s2;

    cin >> s1 >>s2;

    s2 += s1;

    cout << s2;

    return 0;





}


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

int main() {

	

	char character1[100];

	char character2[100];

	

	scanf("%s", character1);

	scanf("%s", character2);

	printf("%s%s", character2, character1);

	

	return 0;

}

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

using namespace std;

int main()

{

    char s[101],t[101];

    cin>>s>>t;

    cout<<t<<s<<endl;

}


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

int main() {

	

	char character1[100];

	char character2[100];

	

	scanf("%s", character1);

	scanf("%s", character2);

	printf("%s%s", character2, character1);

	

	return 0;

}

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

using namespace std;



int main() {

    ios::sync_with_stdio(0);

    cin.tie(0);

    string a, b;

    cin >> a >> b;

    b += a;

    cout << b << "\n";

    return 0;

}

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

int main() {

	

	char character1[100];

	char character2[100];

	

	scanf("%s", character1);

	scanf("%s", character2);

	printf("%s%s", character2, character1);

	

	return 0;

}

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

using namespace std;



#define ll long long

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



int main()

{

    fast_in_out;

    string s,t;

    cin >> s >> t;

    cout << t << s;

}


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

int main() {

	

	char character1[100];

	char character2[100];

	

	scanf("%s", character1);

	scanf("%s", character2);

	printf("%s%s", character2, character1);

	

	return 0;

}

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



using namespace std;



int main()

{

    string a,b;

    cin>>a;

    cin>>b;

    cout<<b<<a;

    return 0;

}


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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

#include <string>

using namespace std;



int main()

{

	string s,t,r;

	cin>>s>>t;

	r = t+s;

	cout<<r;

	return 0;

}




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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

using namespace std;

int main()

{

    string s,t;

    cin>>s>>t;

    cout<<t<<s<<endl;

}






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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

using namespace std;

int main()

{

     string s,t;

     cin>>s>>t;

     cout<<t<<s<<endl;

     return 0;

}


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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

using namespace std;



int main() {

	string t, s;

	cin>>s>>t;

	cout<<t+s<<endl;

	

	return 0;

}

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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

#include <string>

using namespace std;

int main() {

    string S,T;

    cin>>S>>T;

    

    cout<<T+S<<endl;

	

	return 0; 

}

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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

using namespace std;

int main ()

{

char S[100],T[100];

cin>>S>>T;

cout<<T<<S<<endl;



}

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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

using namespace std;

int main()

{

    string S,T,c;

    cin>>S>>T;

    c=T+S;

    cout<<c<<endl;

    return 0;





}

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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

using namespace std;



#define ll long long

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



int main()

{

    fast_io;

    string s,t;

    cin >> s >> t;

    cout << t << s;

}


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



 int main(){

 	char character;

	char char1[102];

    scanf("%s",char1 );

    

    char character2;

 	char char2[102]; 

	scanf("%s",char2 ); 

	

	printf("%s%s", char2,char1 );	



	return 0;

}

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

using namespace std;

int main(){

     string s,t;

     cin>>s>>t;

     cout<<t+s<<endl;

     return 0;

}

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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

using namespace std;

int main(){

    string a, b;

    cin>> a >> b;

    cout<<b<<a;

}

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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

#include<bits/stdc++.h>

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2<<s1;

    return 0;

}


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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

using namespace std;

int main()

{

	string A,T;

	cin>>A;

	cin.ignore();

	cin>>T;

	string C=T+A;

	cout<<C;

	return 0;

}

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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

using namespace std;

int main()

{

	string x;

	string y;

	cin>>x;

	cin>>y;

	string z;

	z=x;

	x=y;

	y=z;

	cout<<x<<y;

	

}

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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

using namespace std;

int main()

{

string a,b,c;

cin>>a>>b;

c=a;

a=b;

b=c;

cout<<a<<b;

}

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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

using namespace std;

typedef long long int ll;

int main()

{

    string t,s,a;

   while( cin>>s>>t)

   {

    a=t+s;

    cout<<a<<endl;

   }



}


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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

#include <string>

using namespace std;



int main()

{

	string s,t;

	int z,k=0;

	cin>>s>>t;

	cout<<t<<s<<'\n';

	

}

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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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



using namespace std ;



int main()



{

    char str1[200], str2[200] ;



    cin>>str1>>str2 ;



    cout<<str2<<str1<<endl ;



    return 0;

}

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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

using namespace std;

int main()

{

    char S[100],T[100];

    cin>>S>>T;



    cout<<T<<S<<endl;

    return 0;

}


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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

#include <cstdio>



using namespace std;



int main()

{

    string S,T,a;



    cin>>S;

    cin>>T;



    a=T+S;

    cout<<a;





    return 0;

}

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

#include <string.h>



int main()

{

    char S[255], T[255];

    scanf("%s%s", S, T);

    strcat(T,S);

    printf("%s",T);



    return 0;

}

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

#include <iostream>

#include<string>

using namespace std;

int main(){

	string T,S;

	cin>>S>>T;

	cout<<T<<S;

	return 0;





}

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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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

#include<string.h>

using namespace std;



void function(char *s,char *t)

{

    strcat(t,s);

    cout<<t<<endl;

}



int main()

{

    char s[500];

    char t[500];

    cin>>s;

    cin>>t;

    function(s,t);

    return 0;

}


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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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

using namespace std;



int main(){



    string s1,s2;

    cin>>s1>>s2;

    string m="";

    m=m+s2;

    m=m+s1;

   /// m=m+'\0';

    cout<<m<<endl;









    return 0;

}




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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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

using namespace std;

int main()

{

    string s,t;

    cin>>s>>t;

    cout<<t<<s<<endl;

}


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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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

using namespace std;

string s, t;

int main() {

    cin >> s >> t;

    cout << t << s << "\n"  ;

    return 0;

}

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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<algorithm>

#include<string>

#include<stack>

//#define ll long long

using namespace std;

const int maxn=100;

const int INF=1000000000;

string str1,str2;



int main()

{

    cin>>str1>>str2;

    cout<<str2<<str1;

}


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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2+s1<<endl;



    return 0;

}


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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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

using namespace std;

int main()

{

    string s,t;

    cin>> s>> t;

    cout<< t<<s;

}


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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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



using namespace std;



int main()

{

    string s,t;

    cin>>s;

    cin>>t;

    cout<<t+s;

}

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



int main()

{

	char S[100];

	char T[100];

	scanf("%s %s", &S,&T);

	getchar();

	printf("%s%s", T, S);

	

	

	return 0;

}


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

using namespace std;

int c[999999];

int main(){

      int a,q=0,i,mn=9999999;

      cin>>a;

      for (i=1;i<=a;++i){

            cin>>c[i];

            q+=c[i];

            mn=min(c[i],mn);

      }

      cout <<q+(mn-a)-mn;

}


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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

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

#include <algorithm>

#include <sstream>

#include <string>

#include <queue>

#include <cstdio>

#include <map>

#include <set>

#include <utility>

#include <stack>

#include <cstring>

#include <cmath>

#include <vector>

#include <ctime>

#include <bitset>

#include <assert.h>

#include <iomanip>

using namespace std;

#define pb push_back

#define sd(n) scanf("%d",&n)

#define sdd(n,m) scanf("%d%d",&n,&m)

#define sddd(n,m,k) scanf("%d%d%d",&n,&m,&k)

#define sld(n) scanf("%lld",&n)

#define sldd(n,m) scanf("%lld%lld",&n,&m)

#define slddd(n,m,k) scanf("%lld%lld%lld",&n,&m,&k)

#define sf(n) scanf("%lf",&n)

#define sff(n,m) scanf("%lf%lf",&n,&m)

#define sfff(n,m,k) scanf("%lf%lf%lf",&n,&m,&k)

#define ss(str) scanf("%s",str)

#define ansn() printf("%d\n",ans)

#define lansn() printf("%lld\n",ans)

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

#define r1(i,e) for(int i=1;i<=e;++i)

#define rn(i,e) for(int i=e;i>=1;--i)

#define mst(abc,bca) memset(abc,bca,sizeof abc)

#define lowbit(a) (a&(-a))

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

#define pii pair<int,int>

#define pll pair<long long,long long>

#define mp(aa,bb) make_pair(aa,bb)

#define lrt rt<<1

#define rrt rt<<1|1

#define X first

#define Y second

#define PI (acos(-1.0))

double pi = acos(-1.0);

typedef long long ll;

typedef unsigned long long ull;

typedef long double ld;

//const ll mod = 1000000007;

const double eps=1e-12;

const int inf=0x3f3f3f3f;

//const ll infl = 100000000000000000;//1e17

const int maxn=  2e6+20;

const int maxm = 5e3+20;

//muv[i]=(p-(p/i))*muv[p%i]%p;

inline int in(int &ret) {

    char c;

    int sgn ;

    if(c=getchar(),c==EOF)return -1;

    while(c!='-'&&(c<'0'||c>'9'))c=getchar();

    sgn = (c=='-')?-1:1;

    ret = (c=='-')?0:(c-'0');

    while(c=getchar(),c>='0'&&c<='9')ret = ret*10+(c-'0');

    ret *=sgn;

    return 1;

}

int a[maxn];

ll lcm(ll x,ll y)

{

    ll gcd = __gcd(x,y);

    return x/gcd*y;

}

int main() {

#ifdef LOCAL

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

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

#endif // LOCAL



    int n;

    sd(n);

    ll ans = 0;

    r1(i,n)sd(a[i]),ans += a[i] - 1;

    lansn();

    return 0;

}


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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

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

using namespace std;



int main()

{

    int n,x,ans=0;

    cin>>n;

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

    {

        cin>>x;

        ans+=x;

    }

    cout<<ans-n;

    return 0;

}


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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

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

#include<cstdio>

#include<vector>

using namespace std;



int main(){

	int i,j,n,*a;

	long long result=0;

	scanf("%d",&n);

	a=new int[n];

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

		scanf("%d",&a[i]);

		result=result+a[i]-1;

	}

	printf("%lld",result);

	return 0;

	system("pause");

}

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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

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

#include <vector>

#include <algorithm>

#include <queue>

#define MAX_NUM 50001

#include <iomanip>

#include <string>

using namespace std;





int main()

{

    int ans=0,N,temp;

    cin>>N;

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

    {

        cin>>temp;

        ans+=temp-1;

    }

    cout<<ans;





}


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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

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

#include <stdio.h>

#include <math.h>

#include <algorithm>

#include <string>

#include <map>

#include <queue>

#include <vector>

#include <string.h>

using namespace std;

int a[3001];

int f[3000];

int main()

{

    int n;

    scanf("%d",&n);

    int sum = 0;

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

        scanf("%d",&a[i]);

        sum+=(a[i]-1);

    }

    printf("%d",sum);

	return 0;

}


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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#define _CRT_SECURE_NO_WARNINGS

#include<iostream>

#include <vector>

#include<algorithm>

#include<string>

#include<string.h>

#include<math.h>

#include <cstdio>

#include <queue>

#include<stack>



using namespace std;



int main() {

	int n;

	long long x;

	cin >> n;

	int * a = new int[n];

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

	{

		cin >> a[i];

	}



	long long s = 0;

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

		s += a[j]-1;

	cout << s;

	return 0;

}


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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

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

#include<cstdio>

#include<queue>

#include<cstring>

#include<algorithm>

#include<vector>

#include<map>

#include<sstream>

typedef long long LL;

using namespace std;



LL a[3010];

int main()

{

    int n;

    scanf("%d",&n);

    int s=0;

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

        scanf("%lld",&a[i]),s+=a[i]-1;



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

    return 0;

}

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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

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

#include<cstdio>

#include<cstring>

using namespace std;

typedef long long ll;

ll num[23333];



int main()

{

	ll n;

	cin >> n;

	for(int i = 1;i <= n;i ++) cin >> num[i];

	ll x = 1,ans = 0;

	for(int i = 1;i <= n;i ++) ans += (num[i] - 1);

	cout << ans;

	return 0; 

}

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

int main(){

	long long int n;

	long long int a[10100];

        long long int cnt=0;

	scanf("%lld",&n);

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

		scanf("%lld",&a[i]);

	    cnt+=a[i];

	}

	printf("%lld",cnt-n);

	return 0;

} 

// Fastest known solution for this problem: