stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

#define ll long long

using namespace std;

const int N = 2e5 + 5;

int a[N];

void kill() {

	cout << "-1\n";

	exit(0);

}

int main() {

	ios_base::sync_with_stdio(0);

	cin.tie(0);

	int n;

	cin >> n;

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

		cin >> a[i];

	a[0] = -1;

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

		if (a[i] - a[i - 1] > 1) kill();

	ll ans = 0;

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

		if (!a[i]) continue;

		ans++;

		if (a[i - 1] + 1 != a[i]) ans += a[i] - 1;

	}

	cout << ans << endl;

	return 0;

}




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



const int maxn=200000;



int read()

{

  int x=0,f=1;

  char ch=getchar();

  while((ch<'0')||(ch>'9'))

    {

      if(ch=='-')

        {

          f=-f;

        }

      ch=getchar();

    }

  while((ch>='0')&&(ch<='9'))

    {

      x=x*10+ch-'0';

      ch=getchar();

    }

  return x*f;

}



int n,a[maxn+10];

long long ans;



int main()

{

  n=read();

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

    {

      a[i]=read();

      if(a[i]>=i)

        {

          puts("-1");

          return 0;

        }

    }

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

    {

      if(a[i]>a[i-1]+1)

        {

          puts("-1");

          return 0;

        }

      if(a[i]==a[i-1]+1)

        {

          ++ans;

        }

      else

        {

          ans+=a[i];

        }

    }

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

  return 0;

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

#include <string.h>



using namespace std;



int N[210000];

long long ans,n;



bool mtime()

{

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

    {

        if(N[i]-N[i-1]>1||N[i]>i)

            return true;

    }

    return false;

}



int main()

{

    cin>>n;

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

    {

        cin>>N[i];

    }

    if(N[0]!=0||mtime())

    {

        cout<<-1<<endl;

        return 0;

    }

    ans=0;

    ans+=N[n-1];

    for(int i=n-2; i>0; i--)

    {

        if(N[i]-N[i+1]>-1)

            ans+=N[i];

    }

    cout<<ans<<endl;

    return 0;

}

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



const int maxn=200000;



int read()

{

  int x=0,f=1;

  char ch=getchar();

  while((ch<'0')||(ch>'9'))

    {

      if(ch=='-')

        {

          f=-f;

        }

      ch=getchar();

    }

  while((ch>='0')&&(ch<='9'))

    {

      x=x*10+ch-'0';

      ch=getchar();

    }

  return x*f;

}



int n,a[maxn+10];

long long ans;



int main()

{

  n=read();

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

    {

      a[i]=read();

      if(a[i]>=i)

        {

          puts("-1");

          return 0;

        }

    }

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

    {

      if(a[i]>a[i-1]+1)

        {

          puts("-1");

          return 0;

        }

      if(a[i]==a[i-1]+1)

        {

          ++ans;

        }

      else

        {

          ans+=a[i];

        }

    }

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

  return 0;

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

#include<sstream>

#include<algorithm>

#include<set>

#include<map>

#include<queue>

#include<complex>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<cassert>

using namespace std;



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

#define each(i,c) for(__typeof(c.begin()) i=c.begin();i!=c.end();i++)

#define pb push_back

#define mp make_pair

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

#define dbg(x) cerr<<__LINE__<<": "<<#x<<" = "<<(x)<<endl



typedef long long ll;

typedef vector<int> vi;

typedef pair<int,int> pi;

const int inf=(int)1e9;

const double EPS=1e-9, INF=1e12;



const int mod = (int)1e8 + 7;

int h, w, pw[11];

char in[12][12];

int dp[2][11][3][60000];



int main(){

	pw[0] = 1;

	rep(i, 10) pw[i + 1] = pw[i] * 3;

	

	cin >> h >> w;

	rep(i, h) cin >> in[i];

	

	int cur = 0, next = 1;

	dp[0][0][0][0] = 1;

	

	rep(i, h){

		memset(dp[next], 0, sizeof(dp[next]));

		rep(j, w){

			rep(l, 3) rep(u, pw[w]) if(dp[cur][j][l][u]){

				

				int tu = u / pw[j] % 3;

				

				if(in[i][j] == '.'){

					if(tu && l) continue;

					(dp[cur][j + 1][l][u] += dp[cur][j][l][u]) %= mod;

					continue;

				}

				int rest = in[i][j] - '0' - tu - l;

				rep(nl, 3){

					int nu = rest - nl;

					if(nu < 0 || nu > 2) continue;

					(dp[cur][j + 1][nl][u + pw[j] * (nu - tu)] += dp[cur][j][l][u]) %= mod;

				}

			}

		}

		rep(u, pw[w]) dp[next][0][0][u] = dp[cur][w][0][u];

		swap(cur, next);

	}

	cout << dp[cur][0][0][0] << endl;

	

	return 0;

}

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

#include<sstream>

#include<algorithm>

#include<set>

#include<map>

#include<queue>

#include<complex>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<cassert>

using namespace std;



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

#define each(i,c) for(__typeof(c.begin()) i=c.begin();i!=c.end();i++)

#define pb push_back

#define mp make_pair

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

#define dbg(x) cerr<<__LINE__<<": "<<#x<<" = "<<(x)<<endl



typedef long long ll;

typedef vector<int> vi;

typedef pair<int,int> pi;

const int inf=(int)1e9;

const double EPS=1e-9, INF=1e12;



const int mod = (int)1e8 + 7;

int h, w, pw[11];

char in[12][12];

int dp[2][3][60000];



int main(){

	pw[0] = 1;

	rep(i, 10) pw[i + 1] = pw[i] * 3;

	

	cin >> h >> w;

	rep(i, h) cin >> in[i];

	

	int cur = 0, next = 1;

	dp[0][0][0] = 1;

	

	rep(i, h) rep(j, w){

		memset(dp[next], 0, sizeof(dp[next]));

		rep(l, 3) rep(u, pw[w]) if(dp[cur][l][u]){

			

			int tu = u / pw[j] % 3;

			

			if(in[i][j] == '.'){

				if(tu && l) continue;

				if(l == 0 || j < w - 1) (dp[next][l][u] += dp[cur][l][u]) %= mod;

				continue;

			}

			int rest = in[i][j] - '0' - tu - l;

			rep(nl, 3){

				int nu = rest - nl;

				if(nu < 0 || nu > 2) continue;

				if(nl == 0 || j < w - 1)

					(dp[next][nl][u + pw[j] * (nu - tu)] += dp[cur][l][u]) %= mod;

			}

		}

		swap(cur, next);

	}

	cout << dp[cur][0][0] << endl;

	

	return 0;

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

#include <queue>

#include <cmath>

#include <algorithm>

#include <iostream>

#include <set>

#include <map>

#include <string>

#include <algorithm>

using namespace std;

#include <string>

#include <cstdio>

#define ll long long

#define TLE std::ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

typedef pair<int,int> pii;

const ll mod = 1000000007 ;

const int INF=0x3f3f3f3f;

#define test(n) cout<<"Test "<<n<<endl;

#define pb push_back

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

#define rep(n,m) for(int i=1;i<=n;i++) for(int j=1;j<=m;j++)

ll ksm(ll x,ll n){ll ans=1;while (n){if (n&1)ans=(ans*x)%mod;x=x*x%mod;n>>=1;}return ans;}

using namespace std;

double pi = atan(1.0)*4 ;

const int mxn = 1e3+7 ;

int n,t,m,k,l,r;

/// ll mat[mxn][mxn], prime[mxn], isprime[mxn];

ll phi[mxn];

string str;char ch[27][27] ;

int a[mxn][mxn];

ll exgcd(ll a,ll b, ll &x ,ll &y)

{

    if(!a&&!b) return -1;/// 无最大公约数

    if(!b) {x=1,y=0;return a;}

    ll d=exgcd(b,a%b,y,x);

    y-=a/b*x ;

    return d;

}

int vis[mxn][mxn];

int main()

{



    rep(3,3) vis[i][j] = 0 ;

    map<int,pair<int,int> >mp;

    rep(3,3) {cin>>a[i][j];mp[ a[i][j] ] = {i,j} ;}

    cin>>n;

    rp(n){ cin>>k;pair<int,int>tmp = mp[k];



    if(mp.find(k)!=mp.end() && tmp.first<=3 && tmp.second<=3 && tmp.first>0 && tmp.second>0)

        vis[ tmp.first ][ tmp.second ] = 1 ;

    }

    int f1 = 0 ;

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

    {

        int ans = 0 ;

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

            if(vis[i][j]==1)

                ans++;

        if(ans==3) {cout<<"Yes"<<endl;f1=1;break;}

    }

    if(!f1)

    {

        if(vis[1][1]&&vis[2][2]&&vis[3][3] || vis[1][3]&&vis[2][2]&&vis[3][1])

            {cout<<"Yes"<<endl;f1=1;}

    }

    if(!f1)

    {

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

        {

            int ans = 0 ;

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

                if(vis[j][i]==1)

                    ans++;

            if(ans==3) {cout<<"Yes"<<endl;f1=1;break;}

        }

    }

    if(!f1) cout<<"No"<<endl;

}




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



int main(){

	int a[3][3], c[3][3]={0};

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

		for(int j=0;j<3;j++){

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

		}

	}

	int N;

	scanf("%d", &N);

	int b[N];

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

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

	}

	for(int k=0;k<N;k++){

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

			for(int j=0;j<3;j++){

				if(a[i][j] == b[k]){

					c[i][j]++;	

				}

			}

		}

	}

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

		if(c[i][0]+c[i][1]+c[i][2] == 3){

			printf("Yes\n");

			return 0;

		}

		if(c[0][i]+c[1][i]+c[2][i] == 3){

			printf("Yes\n");

			return 0;

		}

	}

	if(c[0][0]+c[1][1]+c[2][2] == 3){

		printf("Yes\n");

		return 0;

	}

	if(c[2][0]+c[1][1]+c[0][2] == 3){

		printf("Yes\n");

		return 0;

	}

	printf("No\n");

	return 0;

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

#include<cstdio>

#include<cstring>

#include<string>

#include<algorithm>

#include<queue>

#include<stack>

#include<vector>

#include<set>

#include<map>

using namespace std;

typedef long long ll;

int main()

{

    int s[5][5];

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

    {

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

        {

            cin>>s[i][j];

        }

    }

    int n;

    int b[5][5]= {0};

    cin>>n;

    while(n--)

    {

        int x;

        cin>>x;

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

        {

            int ff=0;

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

            {

                if(s[i][j]==x&&b[i][j]==0)

                {

                    b[i][j]=1;

                    ff=1;

                    break;

                }

            }

            if(ff==1)

                break;

        }

    }

    int flag=0;

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

    {

        if(b[i][1]==1&&b[i][2]==1&&b[i][3]==1)

        {flag=1;break;}

        if(b[1][i]==1&&b[2][i]==1&&b[3][i]==1)

        {flag=1;break;}

    }

    if(b[1][1]==1&&b[2][2]==1&&b[3][3]==1)

        flag=1;

    if(b[1][3]==1&&b[2][2]==1&&b[3][1]==1)

        flag=1;

    if(flag==1)

        cout<<"Yes"<<endl;

    else cout<<"No"<<endl;

    return 0;

}


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



int main(){

	int a[3][3], c[3][3]={0};

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

		for(int j=0;j<3;j++){

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

		}

	}

	int N;

	scanf("%d", &N);

	int b[N];

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

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

	}

	for(int k=0;k<N;k++){

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

			for(int j=0;j<3;j++){

				if(a[i][j] == b[k]){

					c[i][j]++;	

				}

			}

		}

	}

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

		if(c[i][0]+c[i][1]+c[i][2] == 3){

			printf("Yes\n");

			return 0;

		}

		if(c[0][i]+c[1][i]+c[2][i] == 3){

			printf("Yes\n");

			return 0;

		}

	}

	if(c[0][0]+c[1][1]+c[2][2] == 3){

		printf("Yes\n");

		return 0;

	}

	if(c[2][0]+c[1][1]+c[0][2] == 3){

		printf("Yes\n");

		return 0;

	}

	printf("No\n");

	return 0;

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

#include<algorithm>

using namespace std;

int a[5][5];

int b[15];

int ans=0,t=0,teil=0,head=0;

int main()

{

	int n;

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

	{

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

		{

			cin>>a[i][j];

		}

	}

	cin>>n;

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

	{

		cin>>b[i];

	}

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

	{

		ans=0;

		t=0;

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

		{

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

			{

				if(a[i][j]==b[k])

				{

					ans++;

				}

				if(a[j][i]==b[k])

				{

					t++;

				}

			}

		}

		if(ans==3||t==3) break;

	}

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

	{

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

		{

			if(a[i][i]==b[j])

			{

				teil++;

			}

			if(a[4-i][i]==b[j])

			{

				head++;

			}

		}

	}

	if(teil==3||head==3||ans==3||t==3) cout<<"Yes"<<endl;

	else cout<<"No"<<endl;

	return 0;

}


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



int main(){

	int a[3][3], c[3][3]={0};

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

		for(int j=0;j<3;j++){

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

		}

	}

	int N;

	scanf("%d", &N);

	int b[N];

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

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

	}

	for(int k=0;k<N;k++){

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

			for(int j=0;j<3;j++){

				if(a[i][j] == b[k]){

					c[i][j]++;	

				}

			}

		}

	}

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

		if(c[i][0]+c[i][1]+c[i][2] == 3){

			printf("Yes\n");

			return 0;

		}

		if(c[0][i]+c[1][i]+c[2][i] == 3){

			printf("Yes\n");

			return 0;

		}

	}

	if(c[0][0]+c[1][1]+c[2][2] == 3){

		printf("Yes\n");

		return 0;

	}

	if(c[2][0]+c[1][1]+c[0][2] == 3){

		printf("Yes\n");

		return 0;

	}

	printf("No\n");

	return 0;

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

using namespace std;

typedef long long ll;

int main(){

    int arr[3][3];

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

        for (int j=0;j<3;j++){

            cin>>arr[i][j];

        }

    }

    int t,stop=0,win=0;

    cin>>t;

    for (int k=0;k<t;k++){

        int b;

        cin>>b;

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

        for (int j=0;j<3;j++){

            if (arr[i][j]==b)

                arr[i][j]=-1;

            }

        }

    }

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

        if (arr[i][0]==arr[i][1] and arr[i][1]==arr[i][2] and arr[i][2]==-1)

            win =1;

        else if (arr[0][i]==arr[1][i] and arr[1][i]==arr[2][i] and arr[2][i]==-1)

            win =1;

     }

    if (arr[0][0]==arr[1][1] and arr[1][1]==arr[2][2] and arr[2][2]==-1)

            win=1;

    if (arr[0][2]==arr[1][1] and arr[1][1]==arr[2][0] and arr[2][0]==-1)

            win=1;

    if (win){

         cout<<"Yes";

         return 0;

    }

    cout<<"No"<<endl;

}

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



int main(){

	int a[3][3], c[3][3]={0};

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

		for(int j=0;j<3;j++){

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

		}

	}

	int N;

	scanf("%d", &N);

	int b[N];

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

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

	}

	for(int k=0;k<N;k++){

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

			for(int j=0;j<3;j++){

				if(a[i][j] == b[k]){

					c[i][j]++;	

				}

			}

		}

	}

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

		if(c[i][0]+c[i][1]+c[i][2] == 3){

			printf("Yes\n");

			return 0;

		}

		if(c[0][i]+c[1][i]+c[2][i] == 3){

			printf("Yes\n");

			return 0;

		}

	}

	if(c[0][0]+c[1][1]+c[2][2] == 3){

		printf("Yes\n");

		return 0;

	}

	if(c[2][0]+c[1][1]+c[0][2] == 3){

		printf("Yes\n");

		return 0;

	}

	printf("No\n");

	return 0;

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

#include<cstdio>

#include<cstring>

#include<string>

#include<algorithm>

#include<queue>

#include<stack>

#include<vector>

#include<set>

#include<map>

using namespace std;

typedef long long ll;

int main()

{

    int s[5][5];

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

    {

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

        {

            cin>>s[i][j];

        }

    }

    int n;

    int b[5][5]= {0};

    cin>>n;

    while(n--)

    {

        int x;

        cin>>x;

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

        {

            int ff=0;

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

            {

                if(s[i][j]==x&&b[i][j]==0)

                {

                    b[i][j]=1;

                    ff=1;

                    break;

                }

            }

            if(ff==1)

                break;

        }

    }

    int flag=0;

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

    {

        if(b[i][1]==1&&b[i][2]==1&&b[i][3]==1)

        {flag=1;break;}

        if(b[1][i]==1&&b[2][i]==1&&b[3][i]==1)

        {flag=1;break;}

    }

    if(b[1][1]==1&&b[2][2]==1&&b[3][3]==1)

        flag=1;

    if(b[1][3]==1&&b[2][2]==1&&b[3][1]==1)

        flag=1;

    if(flag==1)

        cout<<"Yes"<<endl;

    else cout<<"No"<<endl;

    return 0;

}


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

int main(){

	int na;

	int a[10];

	int angka[3][3];

	int tanda[3][3];

	

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

		for(int j=0;j<3;j++){

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

		}

	}

	scanf("%d", &na);

	for(int c=0;c<na;c++){

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

	for(int  l = 0 ; l < 3 ; l++ ) {

        for(int k = 0 ; k < 3 ; k++ ){

            if( a[c] == angka[l][k] ){

                tanda[l][k] = 1;

                }

            }

        }

    }



    if( (tanda[1][1] == 1 && tanda[2][2] == 1 && tanda[0][0] == 1  )

    || (tanda[2][0] == 1 && tanda[1][1] == 1 && tanda[0][2] == 1  )

    || (tanda[0][0] == 1 && tanda[0][1] == 1 && tanda[0][2] == 1  )

    || (tanda[1][0] == 1 && tanda[1][1] == 1 && tanda[1][2] == 1  )

    || (tanda[2][0] == 1 && tanda[2][1] == 1 && tanda[2][2] == 1  )

    || (tanda[0][0] == 1 && tanda[1][0] == 1 && tanda[2][0] == 1  )

    || (tanda[0][1] == 1 && tanda[1][1] == 1 && tanda[2][1] == 1  )

    || (tanda[0][2] == 1 && tanda[1][2] == 1 && tanda[2][2] == 1  )

    ) {

        printf("Yes\n");

    } else {

        printf("No\n");

    }

	return 0;

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

#include<algorithm>

using namespace std;

int a[5][5];

int b[15];

int ans=0,t=0,teil=0,head=0;

int main()

{

	int n;

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

	{

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

		{

			cin>>a[i][j];

		}

	}

	cin>>n;

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

	{

		cin>>b[i];

	}

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

	{

		ans=0;

		t=0;

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

		{

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

			{

				if(a[i][j]==b[k])

				{

					ans++;

				}

				if(a[j][i]==b[k])

				{

					t++;

				}

			}

		}

		if(ans==3||t==3) break;

	}

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

	{

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

		{

			if(a[i][i]==b[j])

			{

				teil++;

			}

			if(a[4-i][i]==b[j])

			{

				head++;

			}

		}

	}

	if(teil==3||head==3||ans==3||t==3) cout<<"Yes"<<endl;

	else cout<<"No"<<endl;

	return 0;

}


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

int main(){

	int na;

	int a[10];

	int angka[3][3];

	int tanda[3][3];

	

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

		for(int j=0;j<3;j++){

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

		}

	}

	scanf("%d", &na);

	for(int c=0;c<na;c++){

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

	for(int  l = 0 ; l < 3 ; l++ ) {

        for(int k = 0 ; k < 3 ; k++ ){

            if( a[c] == angka[l][k] ){

                tanda[l][k] = 1;

                }

            }

        }

    }



    if( (tanda[1][1] == 1 && tanda[2][2] == 1 && tanda[0][0] == 1  )

    || (tanda[2][0] == 1 && tanda[1][1] == 1 && tanda[0][2] == 1  )

    || (tanda[0][0] == 1 && tanda[0][1] == 1 && tanda[0][2] == 1  )

    || (tanda[1][0] == 1 && tanda[1][1] == 1 && tanda[1][2] == 1  )

    || (tanda[2][0] == 1 && tanda[2][1] == 1 && tanda[2][2] == 1  )

    || (tanda[0][0] == 1 && tanda[1][0] == 1 && tanda[2][0] == 1  )

    || (tanda[0][1] == 1 && tanda[1][1] == 1 && tanda[2][1] == 1  )

    || (tanda[0][2] == 1 && tanda[1][2] == 1 && tanda[2][2] == 1  )

    ) {

        printf("Yes\n");

    } else {

        printf("No\n");

    }

	return 0;

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

using namespace std;

typedef long long ll;

int main(){

    int arr[3][3];

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

        for (int j=0;j<3;j++){

            cin>>arr[i][j];

        }

    }

    int t,stop=0,win=0;

    cin>>t;

    for (int k=0;k<t;k++){

        int b;

        cin>>b;

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

        for (int j=0;j<3;j++){

            if (arr[i][j]==b)

                arr[i][j]=-1;

            }

        }

    }

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

        if (arr[i][0]==arr[i][1] and arr[i][1]==arr[i][2] and arr[i][2]==-1)

            win =1;

        else if (arr[0][i]==arr[1][i] and arr[1][i]==arr[2][i] and arr[2][i]==-1)

            win =1;

     }

    if (arr[0][0]==arr[1][1] and arr[1][1]==arr[2][2] and arr[2][2]==-1)

            win=1;

    if (arr[0][2]==arr[1][1] and arr[1][1]==arr[2][0] and arr[2][0]==-1)

            win=1;

    if (win){

         cout<<"Yes";

         return 0;

    }

    cout<<"No"<<endl;

}

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

int main(){

	int na;

	int a[10];

	int angka[3][3];

	int tanda[3][3];

	

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

		for(int j=0;j<3;j++){

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

		}

	}

	scanf("%d", &na);

	for(int c=0;c<na;c++){

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

	for(int  l = 0 ; l < 3 ; l++ ) {

        for(int k = 0 ; k < 3 ; k++ ){

            if( a[c] == angka[l][k] ){

                tanda[l][k] = 1;

                }

            }

        }

    }



    if( (tanda[1][1] == 1 && tanda[2][2] == 1 && tanda[0][0] == 1  )

    || (tanda[2][0] == 1 && tanda[1][1] == 1 && tanda[0][2] == 1  )

    || (tanda[0][0] == 1 && tanda[0][1] == 1 && tanda[0][2] == 1  )

    || (tanda[1][0] == 1 && tanda[1][1] == 1 && tanda[1][2] == 1  )

    || (tanda[2][0] == 1 && tanda[2][1] == 1 && tanda[2][2] == 1  )

    || (tanda[0][0] == 1 && tanda[1][0] == 1 && tanda[2][0] == 1  )

    || (tanda[0][1] == 1 && tanda[1][1] == 1 && tanda[2][1] == 1  )

    || (tanda[0][2] == 1 && tanda[1][2] == 1 && tanda[2][2] == 1  )

    ) {

        printf("Yes\n");

    } else {

        printf("No\n");

    }

	return 0;

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

#include <queue>

#include <cmath>

#include <algorithm>

#include <iostream>

#include <set>

#include <map>

#include <string>

#include <algorithm>

using namespace std;

#include <string>

#include <cstdio>

#define ll long long

#define TLE std::ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

typedef pair<int,int> pii;

const ll mod = 1000000007 ;

const int INF=0x3f3f3f3f;

#define test(n) cout<<"Test "<<n<<endl;

#define pb push_back

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

#define rep(n,m) for(int i=1;i<=n;i++) for(int j=1;j<=m;j++)

ll ksm(ll x,ll n){ll ans=1;while (n){if (n&1)ans=(ans*x)%mod;x=x*x%mod;n>>=1;}return ans;}

using namespace std;

double pi = atan(1.0)*4 ;

const int mxn = 1e3+7 ;

int n,t,m,k,l,r;

/// ll mat[mxn][mxn], prime[mxn], isprime[mxn];

ll phi[mxn];

string str;char ch[27][27] ;

int a[mxn][mxn];

ll exgcd(ll a,ll b, ll &x ,ll &y)

{

    if(!a&&!b) return -1;/// 无最大公约数

    if(!b) {x=1,y=0;return a;}

    ll d=exgcd(b,a%b,y,x);

    y-=a/b*x ;

    return d;

}

int vis[mxn][mxn];

int main()

{



    rep(3,3) vis[i][j] = 0 ;

    map<int,pair<int,int> >mp;

    rep(3,3) {cin>>a[i][j];mp[ a[i][j] ] = {i,j} ;}

    cin>>n;

    rp(n){ cin>>k;pair<int,int>tmp = mp[k];



    if(mp.find(k)!=mp.end() && tmp.first<=3 && tmp.second<=3 && tmp.first>0 && tmp.second>0)

        vis[ tmp.first ][ tmp.second ] = 1 ;

    }

    int f1 = 0 ;

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

    {

        int ans = 0 ;

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

            if(vis[i][j]==1)

                ans++;

        if(ans==3) {cout<<"Yes"<<endl;f1=1;break;}

    }

    if(!f1)

    {

        if(vis[1][1]&&vis[2][2]&&vis[3][3] || vis[1][3]&&vis[2][2]&&vis[3][1])

            {cout<<"Yes"<<endl;f1=1;}

    }

    if(!f1)

    {

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

        {

            int ans = 0 ;

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

                if(vis[j][i]==1)

                    ans++;

            if(ans==3) {cout<<"Yes"<<endl;f1=1;break;}

        }

    }

    if(!f1) cout<<"No"<<endl;

}




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



int main(){

	

	int matrix[3][3];

	int bingo [3][3] = {0};

	

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

		for(int j=0; j<3; j++){

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

		}

	}

	

	int N;

	scanf("%d", &N);

	

	for(int k=0; k<N; k++){

		int a;

		scanf("%d", &a);

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

			for(int j = 0; j<3; j++){

				if(matrix[i][j] == a){

					bingo[i][j] = 1;

				}

			}

		}

	}

	

	if(bingo[0][0] + bingo[1][1] + bingo[2][2] == 3 || bingo[0][2] +bingo[1][1] +bingo[2][0] == 3){

		printf("Yes\n");

		return 0;

	}for(int i = 0; i < 3;i++){

	if(bingo[i][0]+bingo[i][1]+bingo[i][2]==3||bingo[0][i]+bingo[1][i]+bingo[2][i]== 3){

		printf("Yes\n");

		return 0;

	}

}

printf("No\n");	

	return 0;

}