#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef __int128 lll;
using ull = unsigned long long;
typedef pair<ll,ll> pll;
typedef vector<ll> vll;
typedef vector<pll> vpll;
template<class T> using pqmin = priority_queue<T, vector<T>, greater<T>>;
template<class T> using pqmax = priority_queue<T>;
const ll inf=LLONG_MAX/3;
const ll dx[] = {0, 1, 0, -1, 1, -1, 1, -1};
const ll dy[] = {1, 0, -1, 0, 1, 1, -1, -1};
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) x.begin(),x.end()
#define si(x) ll(x.size())
#define rept(n) for(ll _ovo_=0;_ovo_<n;_ovo_++)
#define rep(i,n) for(ll i=0;i<n;i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define rng(i,l,r) for(ll i=l;i<r;i++)
#define gnr(i,l,r) for(ll i=r-1;i>=l;i--)
#define fore(i, a) for(auto &&i : a)
#define fore2(a, b, v) for(auto &&[a, b] : v)
#define fore3(a, b, c, v) for(auto &&[a, b, c] : v)
template<class T> bool chmin(T& a, const T& b){ if(a <= b) return 0; a = b; return 1; }
template<class T> bool chmax(T& a, const T& b){ if(a >= b) return 0; a = b; return 1; }
template<class T, class U> bool chmin(T& a, const U& b){ return chmin(a, (T)b); }
template<class T, class U> bool chmax(T& a, const U& b){ return chmax(a, (T)b); }
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define STR(...) string __VA_ARGS__;in(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__;in(__VA_ARGS__)
#define vec(type,name,...) vector<type>name(__VA_ARGS__)
#define VEC(type,name,size) vector<type>name(size);in(name)
#define VLL(name,size) vector<ll>name(size);in(name)
#define vv(type,name,h,...) vector<vector<type>> name(h,vector<type>(__VA_ARGS__))
#define VV(type,name,h,w) vector<vector<type>> name(h,vector<type>(w));in(name)
#define vvv(type,name,h,w,...) vector<vector<vector<type>>> name(h,vector<vector<type>>(w,vector<type>(__VA_ARGS__)))
#define SUM(...) accumulate(all(__VA_ARGS__),0LL)
template<class T> auto min(const T& a){ return *min_element(all(a)); }
template<class T> auto max(const T& a){ return *max_element(all(a)); }
template<class T, class F = less<>> void sor(T& a, F b = F{}){ sort(all(a), b); }
template<class T> void uniq(T& a){ sor(a); a.erase(unique(all(a)), end(a)); }
template<class T, class F = less<>> map<T,vector<ll> > ivm(vector<T>& a, F b = F{}){ map<T,vector<ll> > ret; rep(i,si(a))ret[a[i]].push_back(i); return ret;}
template<class T, class F = less<>> map<T,ll> ivc(vector<T>& a, F b = F{}){ map<T,ll> ret; rep(i,si(a))ret[a[i]]++; return ret;}
template<class T, class F = less<>> vector<T> ivp(vector<T> a){ vector<ll> ret(si(a)); rep(i,si(a))ret[a[i]] = i; return ret;}
template<class T, class F = less<>> vector<ll> rev(vector<T> a){ reverse(all(a)); return a;}
template<class T, class F = less<>> vector<ll> sortby(vector<T> a, F b = F{}){vector<ll> w = a; sor(w,b); vector<pll> v; rep(i,si(a))v.eb(a[i],i); sor(v); if(w[0] != v[0].first)reverse(all(v)); vector<ll> ret; rep(i,si(v))ret.pb(v[i].second); return ret;}
template<class T, class P> vector<T> filter(vector<T> a,P f){vector<T> ret;rep(i,si(a)){if(f(a[i]))ret.pb(a[i]);}return ret;}
template<class T, class P> vector<ll> filter_id(vector<T> a,P f){vector<ll> ret;rep(i,si(a)){if(f(a[i]))ret.pb(i);}return ret;}
ll monotone_left(function<bool(ll)> f){ll l = -1,r = (ll)1e18 + 1; assert(f(l + 1) >= f(r - 1)); while(l + 1 < r){ll mid = (l + r)>> 1; (f(mid)?l:r) = mid;} return l;}
ll monotone_left(ll l,ll r,function<bool(ll)> f){l--; assert(f(l + 1) >= f(r - 1)); while(l + 1 < r){ll mid = (l + r)>> 1; (f(mid)?l:r) = mid;} return l;}
ll monotone_right(function<bool(ll)> f){ll l = -1,r = (ll)1e18 + 1; assert(f(l + 1) <= f(r - 1)); while(l + 1 < r){ll mid = (l + r)>> 1; (f(mid)?r:l) = mid;} return r;}
ll monotone_right(ll l,ll r,function<bool(ll)> f){l--; assert(f(l + 1) <= f(r - 1)); while(l + 1 < r){ll mid = (l + r)>> 1; (f(mid)?r:l) = mid;} return r;}
double monotone_double_left(double l,double r,function<bool(double)> f){assert(f(l) >= f(r)); rep(_,100){double mid = (l + r) / 2.0; (f(mid)?l:r) = mid;} return l;}
double monotone_double_right(double l,double r,function<bool(double)> f){assert(f(l) <= f(r)); rep(_,100){double mid = (l + r) / 2.0; (f(mid)?l:r) = mid;} return r;}
template<class S> S unimodal_max(ll l,ll r,function<S(ll)> f){while(l + 2 < r){ll m1 = l + (r - l) / 3,m2 = l + (r - l) / 3 * 2; if(f(m1) < f(m2))l = m1; else r = m2;} S ret = f(l); rng(k,l,r + 1)chmax(ret,f(k)); return ret;}
template<class S> S unimodal_min(ll l,ll r,function<S(ll)> f){while(l + 2 < r){ll m1 = l + (r - l) / 3,m2 = l + (r - l) / 3 * 2; if(f(m1) > f(m2))l = m1; else r = m2;} S ret = f(l); rng(k,l,r + 1)chmin(ret,f(k)); return ret;}
vector<pll> neighbor4(ll x,ll y,ll h,ll w){vector<pll> ret;rep(dr,4){ll xx = x + dx[dr],yy = y + dy[dr]; if(0 <= xx && xx < h && 0 <= yy && yy <w)ret.eb(xx,yy);} return ret;};
vector<pll> neighbor8(ll x,ll y,ll h,ll w){vector<pll> ret;rep(dr,8){ll xx = x + dx[dr],yy = y + dy[dr]; if(0 <= xx && xx < h && 0 <= yy && yy <w)ret.eb(xx,yy);} return ret;};

void outb(bool x){cout<<(x?"Yes":"No")<<"\n";}
ll max(int x, ll y) { return max((ll)x, y); }
ll max(ll x, int y) { return max(x, (ll)y); }
int min(int x, ll y) { return min((ll)x, y); }
int min(ll x, int y) { return min(x, (ll)y); }
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define lbg(c, x) distance((c).begin(), lower_bound(all(c), (x), greater{}))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define ubg(c, x) distance((c).begin(), upper_bound(all(c), (x), greater{}))
ll gcd(ll a,ll b){return (b?gcd(b,a%b):a);}
vector<pll> factor(ull x){ vector<pll> ans; for(ull i = 2; i * i <= x; i++) if(x % i == 0){ ans.push_back({i, 1}); while((x /= i) % i == 0) ans.back().second++; } if(x != 1) ans.push_back({x, 1}); return ans; }
vector<ll> divisor(ull x){ vector<ll> ans; for(ull i = 1; i * i <= x; i++) if(x % i == 0) ans.push_back(i); per(i,ans.size() - (ans.back() * ans.back() == x)) ans.push_back(x / ans[i]); return ans; }
vll prime_table(ll n){vec(ll,isp,n+1,1);vll res;rng(i,2,n+1)if(isp[i]){res.pb(i);for(ll j=i*i;j<=n;j+=i)isp[j]=0;}return res;}
ll powll(lll x,ll y){lll res = 1; while(y){ if(y & 1)res = res * x; x = x * x; y >>= 1;} return res;}
ll powmod(lll x,ll y,lll mod){lll res=1; while(y){ if(y&1)res=res*x%mod; x=x*x%mod; y>>=1;} return res; }
ll modinv(ll a,ll m){ll b=m,u=1,v=0;while(b){ll t=a/b;a-=t*b;swap(a,b);u-=t*v;swap(u,v);}u%=m;if(u<0)u+=m;return u;}

template <class T, class S> pair<T, S> operator-(const pair<T, S> &x) { return pair<T, S>(-x.first, -x.second); }
template <class T, class S> pair<T, S> operator-(const pair<T, S> &x, const pair<T, S> &y) { return pair<T, S>(x.fi - y.fi, x.se - y.se); }
template <class T, class S> pair<T, S> operator+(const pair<T, S> &x, const pair<T, S> &y) { return pair<T, S>(x.fi + y.fi, x.se + y.se); }
template <class T> pair<T, T> operator&(const pair<T, T> &l, const pair<T, T> &r) { return pair<T, T>(max(l.fi, r.fi), min(l.se, r.se)); }
template <class T, class S> pair<T, S> operator+=(pair<T, S> &l, const pair<T, S> &r) { return l = l + r; }
template <class T, class S> pair<T, S> operator-=(pair<T, S> &l, const pair<T, S> &r) { return l = l - r; }
template <class T> bool intersect(const pair<T, T> &l, const pair<T, T> &r) { return (l.se < r.se ? r.fi < l.se : l.fi < r.se); }

template <class T> vector<T> &operator++(vector<T> &v) {
		fore(e, v) e++;
		return v;
}
template <class T> vector<T> operator++(vector<T> &v, int) {
		auto res = v;
		fore(e, v) e++;
		return res;
}
template <class T> vector<T> &operator--(vector<T> &v) {
		fore(e, v) e--;
		return v;
}
template <class T> vector<T> operator--(vector<T> &v, int) {
		auto res = v;
		fore(e, v) e--;
		return res;
}
template <class T> vector<T> &operator+=(vector<T> &l, const vector<T> &r) {
		fore(e, r) l.eb(e);
		return l;
}

template<class... Ts> void in(Ts&... t);
[[maybe_unused]] void print(){}
template<class T, class... Ts> void print(const T& t, const Ts&... ts);
template<class... Ts> void out(const Ts&... ts){ print(ts...); cout << '\n'; }
namespace IO{
#define VOID(a) decltype(void(a))
struct S{ S(){ cin.tie(nullptr)->sync_with_stdio(0); fixed(cout).precision(12); } }S;
template<int I> struct P : P<I-1>{};
template<> struct P<0>{};
template<class T> void i(T& t){ i(t, P<3>{}); }
void i(vector<bool>::reference t, P<3>){ int a; i(a); t = a; }
template<class T> auto i(T& t, P<2>) -> VOID(cin >> t){ cin >> t; }
template<class T> auto i(T& t, P<1>) -> VOID(begin(t)){ for(auto&& x : t) i(x); }
template<class T, size_t... idx> void ituple(T& t, index_sequence<idx...>){ in(get<idx>(t)...); }
template<class T> auto i(T& t, P<0>) -> VOID(tuple_size<T>{}){ ituple(t, make_index_sequence<tuple_size<T>::value>{}); }
template<class T> void o(const T& t){ o(t, P<4>{}); }
template<size_t N> void o(const char (&t)[N], P<4>){ cout << t; }
template<class T, size_t N> void o(const T (&t)[N], P<3>){ o(t[0]); for(size_t i = 1; i < N; i++){ o(' '); o(t[i]); } }
template<class T> auto o(const T& t, P<2>) -> VOID(cout << t){ cout << t; }
template<class T> auto o(const T& t, P<1>) -> VOID(begin(t)){ bool first = 1; for(auto&& x : t) { if(first) first = 0; else o(' '); o(x); } }
template<class T, size_t... idx> void otuple(const T& t, index_sequence<idx...>){ print(get<idx>(t)...); }
template<class T> auto o(T& t, P<0>) -> VOID(tuple_size<T>{}){ otuple(t, make_index_sequence<tuple_size<T>::value>{}); }
#undef VOID
}
#define unpack(a) (void)initializer_list<int>{(a, 0)...}
template<class... Ts> void in(Ts&... t){ unpack(IO::i(t)); }
template<class T, class... Ts> void print(const T& t, const Ts&... ts){ IO::o(t); unpack(IO::o((cout << ' ', ts))); }
#undef unpack
template <typename T>
struct Matrix {
		vector<vector<T>> A;
		int n, m;

		Matrix(int n, int m) : A(n, vector<T>(m, 0)), n(n), m(m) {}

		inline const vector<T> &operator[](int k) const { return A[k]; }

		inline vector<T> &operator[](int k) { return A[k]; }

		static Matrix I(int l) {
				Matrix ret(l, l);
				for (int i = 0; i < l; i++) ret[i][i] = 1;
				return ret;
		}

		Matrix &operator*=(const Matrix &B) {
				assert(m == B.n);
				Matrix ret(n, B.m);
				for (int i = 0; i < n; i++) {
						for (int k = 0; k < m; k++) {
								for (int j = 0; j < B.m; j++) ret[i][j] += A[i][k] * B[k][j];
						}
				}
				swap(A, ret.A);
				m = B.m;
				return *this;
		}

		Matrix operator*(const Matrix &B) const { return Matrix(*this) *= B; }

		Matrix pow(long long k) const {
				assert(n == m);
				Matrix now = *this, ret = I(n);
				for (; k > 0; k >>= 1, now *= now) {
						if (k & 1) ret *= now;
				}
				return ret;
		}

		bool eq(const T &a, const T &b) const {
				return a == b;
				// return abs(a-b) <= EPS;
		}

		// 行基本変形を用いて簡約化を行い、(rank, det) の組を返す
		pair<int, T> row_reduction(vector<T> &b) {
				assert((int)b.size() == n);
				if (n == 0) return make_pair(0, m > 0 ? 0 : 1);
				int check = 0, rank = 0;
				T det = (n == m ? 1 : 0);
				assert(b.size() == n);
				for (int j = 0; j < m; j++) {
						int pivot = check;
						for (int i = check; i < n; i++) {
								if (A[i][j] != 0) pivot = i;
								// if(abs(A[i][j]) > abs(A[pivot][j])) pivot = i; // T が小数の場合はこちら
						}
						if (check != pivot) det *= T(-1);
						swap(A[check], A[pivot]), swap(b[check], b[pivot]);
						if (eq(A[check][j], T(0))) {
								det = T(0);
								continue;
						}
						rank++;
						det *= A[check][j];
						T r = T(1) / A[check][j];
						for (int k = j + 1; k < m; k++) A[check][k] *= r;
						b[check] *= r;
						A[check][j] = T(1);
						for (int i = 0; i < n; i++) {
								if (i == check) continue;
								if (!eq(A[i][j], 0)) {
										for (int k = j + 1; k < m; k++) A[i][k] -= A[i][j] * A[check][k];
										b[i] -= A[i][j] * b[check];
								}
								A[i][j] = T(0);
						}
						if (++check == n) break;
				}
				return make_pair(rank, det);
		}

		pair<int, T> row_reduction() {
				vector<T> b(n, T(0));
				return row_reduction(b);
		}

		// 行基本変形を行い、逆行列を求める
		pair<bool, Matrix> inverse() {
				if (n != m) return make_pair(false, Matrix(0, 0));
				if (n == 0) return make_pair(true, Matrix(0, 0));
				Matrix ret = I(n);
				for (int j = 0; j < n; j++) {
						int pivot = j;
						for (int i = j; i < n; i++) {
								if (A[i][j] != 0) pivot = i;
								// if(abs(A[i][j]) > abs(A[pivot][j])) pivot = i; // T が小数の場合はこちら
						}
						swap(A[j], A[pivot]), swap(ret[j], ret[pivot]);
						if (eq(A[j][j], T(0))) return make_pair(false, Matrix(0, 0));
						T r = T(1) / A[j][j];
						for (int k = j + 1; k < n; k++) A[j][k] *= r;
						for (int k = 0; k < n; k++) ret[j][k] *= r;
						A[j][j] = T(1);
						for (int i = 0; i < n; i++) {
								if (i == j) continue;
								if (!eq(A[i][j], T(0))) {
										for (int k = j + 1; k < n; k++) A[i][k] -= A[i][j] * A[j][k];
										for (int k = 0; k < n; k++) ret[i][k] -= A[i][j] * ret[j][k];
								}
								A[i][j] = T(0);
						}
				}
				return make_pair(true, ret);
		}

		// Ax = b の解の 1 つと解空間の基底の組を返す
		vector<vector<T>> Gaussian_elimination(vector<T> b) {
				row_reduction(b);
				vector<vector<T>> ret;
				vector<int> p(n, m);
				vector<bool> is_zero(m, true);
				for (int i = 0; i < n; i++) {
						for (int j = 0; j < m; j++) {
								if (!eq(A[i][j], T(0))) {
										p[i] = j;
										break;
								}
						}
						if (p[i] < m) {
								is_zero[p[i]] = false;
						} else if (!eq(b[i], T(0))) {
								return {};
						}
				}
				vector<T> x(m, T(0));
				for (int i = 0; i < n; i++) {
						if (p[i] < m) x[p[i]] = b[i];
				}
				ret.push_back(x);
				for (int j = 0; j < m; j++) {
						if (!is_zero[j]) continue;
						x[j] = T(1);
						for (int i = 0; i < n; i++) {
								if (p[i] < m) x[p[i]] = -A[i][j];
						}
						ret.push_back(x);
						x[j] = T(0);
				}
				return ret;
		}
};

using mat=Matrix<ll>;

int main(){
	cin.tie(0);
	ios::sync_with_stdio(0);
	ll n = 2;
	mat A(n,n),B(n,n);
	rep(i,n)rep(j,n)cin>>A.A[i][j];
	rep(i,n)rep(j,n)cin>>B.A[i][j];
	mat C = A * B * A * B;
	rep(i,n){
		rep(j,n)cout<<C.A[i][j]<<" \n"[j == n - 1];
	}
}