#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC target("avx,avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("Ofast,fast-math")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include<bits/stdc++.h>
//#include<iostream>
//#include<string>
//#include<cmath>
//#include<cstdio>
//#include<cctype>
//#include<cstring>
//#include<iomanip>
//#include<cstdlib>
//#include<ctime>
//#include<set>
//#include<map>
//#include<utility>
//#include<queue>
//#include<vector>
//#include<stack>
//#include<sstream>
//#include<algorithm>
using namespace std;
/*=====================================================================*/
#define ll long long
#define int ll
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pii>
#define pdd pair<double,double>
#define ull unsigned long long
#define pb push_back
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define all(s) (s).begin(),(s).end()
#define repd(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define forr(i,a,b,c) for(int i=(int)(a);i<=(int)(b);i+=(int)(c))
#define forn(i,p,n) for(int i=(int)(p);i<=(int)(n);++i)
#define ford(i,p,n) for(int i=(int)(n);i>=(int)(p);--i)
#define foreach(i,c) for(__typeof(c.begin())i=(c.begin());i!=(c).end();++i)
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define Endl(x) cout<<x<<endl;
#define Blank(x) cout<<x<<" ";
#define modcg(x) if(x>=mod)x-=mod;
#define modcl(x) if(x<0)x+=mod;
#define lowbit(x) x&(-x)
/*=====================================================================*/
string int_to_string(ll n)
{
	string s="";
	while(n)
	{
		ll now=n%10;
		s+=now+'0';
		n/=10;
	}
	reverse(s.begin(),s.end());
	return s;
}
ll string_to_int(string s)
{
	ll n=0;
	rep(i,s.size())
	{
		n*=10;
		n+=s[i]-'0';
	}
	return n;
}
mt19937 GeN(chrono::system_clock::now().time_since_epoch().count());
int Rand(int l,int r)
{
	uniform_int_distribution<>RAND1(l,r);
	return RAND1(GeN);
}
/*======================================================================*/
const int dx[]={-1,0,1,0};
const int dy[]={0,-1,0,1};
const int month[2][12]={{31,28,31,30,31,30,31,31,30,31,30,31},{31,29,31,30,31,30,31,31,30,31,30,31}};
//think twice,code once
//think once,debug forever
const int MAXN=480020;
const int mod=998244353,gen=3,igen=332748118;
int quickpower(int a,int b)
{
	int res=1;
	while(b)
	{
		if(b&1)
		{
			res*=a;
			res%=mod;
		}
		a*=a;
		a%=mod;
		b>>=1;
	}
	return res;
}
int inv(int x)
{
	return quickpower(x,mod-2);
}
struct Poly
{
	int r[MAXN];
	int limit,l,invl;
	void init(int n)
	{
		l=0;
		limit=1;
		while(limit<n)
		{
			limit<<=1;
			l++; 
		}
		invl=::inv(limit);
		rep(i,limit)
		{
			r[i]=(r[i>>1]>>1ll)|((i&1ll)<<(l-1));
		}
	}
	void NTT(vi &a,bool type)
	{
		a.resize(limit);
		rep(i,limit) 
		{
			if(i<r[i])
			{
				swap(a[i],a[r[i]]);
			}
		}
		for(int i=2;;i<<=1)
		{
			if(i>limit)
			{
				break;
			}
			int Gen=quickpower(((type==1)?gen:igen),(mod-1)/i);
			forr(j,0,limit-1,i)
			{
				int w=1;
				forn(k,j,(i>>1)+j-1)
				{
					int cur=w*a[k+(i>>1)]%mod;
					a[k+(i>>1)]=((a[k]-cur)%mod+mod)%mod;
					a[k]=(a[k]+cur)%mod;
					w*=Gen;
					w%=mod;
				}
			}
		}
	}
	vi mul(vi f,vi g)
	{
		int n=f.size();
		int m=g.size();	
		init(n+m);
		NTT(f,1);
		NTT(g,1);
		rep(i,limit)
		{
			f[i]=f[i]*g[i]%mod*invl%mod;
		}
		NTT(f,0);
		f.resize(n+m);
		return f;
	}
	vi inv(vi f)
	{
		if(f.size()==1)
		{
			f[0]=::inv(f[0]);
			return f;
		}
		int all=f.size();
		vi nf=f;
		nf.resize((all+1)/2);	
		nf=inv(nf);
		vi nf1=nf;
		nf1=mul(nf1,f);
		nf1.resize(all);
		rep(i,nf1.size())
		{
			nf1[i]=-nf1[i];
			modcl(nf1[i]);
		}
		nf1[0]+=2;
		modcg(nf1[0]);
		f=mul(nf,nf1);
		f.resize(all);
		return f;
	}
}P;
struct combination
{
	int F[MAXN],invF[MAXN];
	int P[MAXN];
	void init(int n)
	{
		F[0]=1;
		P[0]=1;
		forn(i,1,n)
		{
			F[i]=(F[i-1]*i)%mod;
			P[i]=P[i-1]+P[i-1];
			modcg(P[i]);
		}
		invF[n]=inv(F[n]);
		ford(i,0,n-1)
		{
			invF[i]=(invF[i+1]*(i+1))%mod;
		}
	}
	int C(int n,int m)
	{
		if(n<0||m<0||n<m)
		{
			return 0;
		}
		return ((F[n]*invF[m])%mod*invF[n-m])%mod;
	}
	int A(int n,int m)
	{
		if(n<0||m<0||n<m)
		{
			return 0;
		}
		return F[n]*invF[n-m]%mod;
	}
}C;
int n[3];
int x[3];
int d;
vi ans[3];
void doit(int id)
{
	vi S,A;
	S.resize(d+1);
	A.resize(d+1);
	int a=x[id],b=n[id]+1-x[id];
	forn(i,1,d)
	{
		if((i-a>=0)&&(!((i-a)&1)))
		{
			S[i]+=C.C(i,(i-a)>>1);
			modcg(S[i]);
		}
		if((i-b>=0)&&(!((i-b)&1)))
		{
			S[i]+=C.C(i,(i-b)>>1);
			modcg(S[i]);
		}
		if(!(i&1))
		{
			A[i]+=C.C(i,i>>1);
			modcg(A[i]);
		}
		if((i-n[id]-1>=0)&&(!((i-n[id]-1)&1)))
		{
			A[i]+=C.C(i,(i-n[id]-1)>>1);
			modcg(A[i]);
		}
	}
	A[0]=1;
//	S[0]=0;
//	for(int u:A)
//	{
//		cout<<u<<" ";
//	}
//	cout<<endl;
//	for(int u:S)
//	{
//		cout<<u<<" ";
//	}
//	cout<<endl;
	A=P.inv(A);
	ans[id]=P.mul(A,S);
	ans[id].resize(d+1);
//	for(int u:ans[id])
//	{
//		cout<<u<<" ";
//	}
//	cout<<endl; 
	ans[id][0]=C.P[0];
	forn(i,1,d)
	{
		ans[id][i]=-ans[id][i];
		modcl(ans[id][i]);
		ans[id][i]+=ans[id][i-1];
		modcg(ans[id][i]);
		ans[id][i]+=ans[id][i-1];
		modcg(ans[id][i]);
	}
	forn(i,0,d)
	{
		ans[id][i]*=C.invF[i];
		ans[id][i]%=mod;
//		cout<<ans[id][i]<<" ";
	}
//	cout<<endl;
}
void solve()
{
	cin>>d;
	rep(i,3)
	{
		cin>>n[i];	
	}
	rep(i,3)
	{
		cin>>x[i];
	}
	C.init(d);
	rep(i,3)
	{
		doit(i);
	}
//	rep(i,3)
//	{
//		for(int u:ans[i])
//		{
//			cout<<u<<" ";
//		}
//		cout<<endl;
//	}
	ans[0]=P.mul(ans[0],ans[1]);
	ans[0].resize(d+1);
	ans[0]=P.mul(ans[0],ans[2]);
	int ANS=ans[0][d]*C.F[d]%mod;
	cout<<ANS<<endl;
}
/*======================================================================*/
signed main()
{
    cin.tie(0);
    cout.tie(0);
	std::ios::sync_with_stdio(false);
//#define Hank2007
#ifdef Hank2007
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
#endif
  	/*====================================================================*/
  	int TEST_CASE=1;
//	cin>>TEST_CASE;
  	while(TEST_CASE--)
  	{
  		solve();
  	}
  	return 0;
}