#include <bits/stdc++.h>
using namespace std;

template<class T>
ostream &operator<<(ostream &os,const vector<T> &v){
	for(int i = 0;i < v.size();i++) os << (i ? "," : "[") << v[i];
	os << "]";
	return os;
}

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

	int size() const{ return A.size(); }
	vector<T> &operator[](const int k){ return A[k]; }
	const vector<T> &operator[](const int k) const{ return A[k]; }
	Matrix operator*(const T &x) const{ Matrix(*this) *= x; }
	Matrix operator*(const Matrix &B) const{ Matrix(*this) *= B; }
	
	Matrix &operator*=(const T &x){
		for(int i = 0;i < A.size();i++){
			for(int j = 0;j < A[0].size();j++) A[i][j] *= x;
		}
		return *this;
	}

	Matrix &operator*=(const Matrix &B) {
		assert(A[0].size() == B.size());
		vector<vector<T>> C(A.size(),vector<T>(B[0].size(),T(0)));
		for(int i = 0;i < A.size();i++){
			for(int k = 0;k < B.size();k++){
				for(int j = 0;j < B[0].size();j++) C[i][j] += A[i][k] * B[k][j];
			}
		}
		A.swap(C);
		return *this;
	}

	vector<T> operator*(const vector<T> &v) const{
		assert(A[0].size() == v.size());
		vector<T> ret(A.size());
		for(int i = 0;i < A.size();i++){
			for(int j = 0;j < v.size();j++) ret[i] += A[i][j] * v[j];
		}
		return ret;
	}

	Matrix pow(long long x) const{
		assert(A.size() == A[0].size());
		Matrix ret = E(A.size()),tmp = *this;
		for(;x;tmp *= tmp,x >>= 1){
			if(x & 1) ret *= tmp;
		}
		return ret;
	}

	static Matrix E(int n){
		Matrix ret(n);
		for(int i = 0;i < n;i++) ret[i][i] = T(1);
		return ret;
	}
};

template<class T>
int gauss_jordan(Matrix<T> &A,bool is_extended = false){
	int n = A.size(),m = A[0].size(),rnk = 0;
	for(int i = 0;i < m;i++){
		if(is_extended && i == m - 1) break;
		int pivot = -1;
		for(int j = rnk;j < n;j++){
			if(A[j][i] != T(0)){
				pivot = j;
				break;
			}
		}
		if(pivot == -1) continue;
		swap(A[pivot],A[rnk]);
		for(int j = m - 1;j >= i;j--) A[rnk][j] /= A[rnk][i];
		for(int j = 0;j < n;j++){
			if(j == rnk) continue;
			for(int k = m - 1;k >= i;k--) A[j][k] -= A[j][i] * A[rnk][k];
		}
		rnk++;
	}
	return rnk;
}

template<class T>
tuple<vector<T>,bool,int> linear_equation(const Matrix<T> &A,const vector<T> &b){
	int n = A.size(),m = A[0].size();
	Matrix<T> B(n,m + 1);
	for(int i = 0;i < n;i++){
		for(int j = 0;j < m;j++) B[i][j] = A[i][j];
		B[i][m] = b[i];
	}
	int rnk = gauss_jordan(B,true);
	vector<T> ret(n);
	for(int i = 0;i < n;i++) ret[i] = B[i][m];
	for(int i = rnk;i < n;i++){
		if(B[i][m] != T(0)) return make_tuple(ret,false,rnk);
	}
	return make_tuple(ret,true,rnk);
}

template<long long mod = 1000000007>
struct modint{
	long long a;

	modint() : a(0){}
	modint(long long t){
		a = t % mod;
		if(a < 0) a += mod;
	}

	operator long long() const{ return a; }

	bool operator==(const modint &x) const{ return a == x.a; }
	bool operator!=(const modint &x) const{ return a != x.a; }

	modint operator-() const{ return modint(a ? (mod - a) : 0); }
	modint operator~() const{ return pow(mod - 2); }

	modint operator+(const modint &x) const{ return modint(*this) += x; }
	modint operator-(const modint &x) const{ return modint(*this) -= x; }
	modint operator*(const modint &x) const{ return modint(*this) *= x; }
	modint operator/(const modint &x) const{ return modint(*this) /= x; }

	modint &operator+=(const modint &x){
		a += x.a;
		if(a >= mod) a -= mod;
		return *this;
	}
	modint &operator-=(const modint &x){
		a -= x.a;
		if(a < 0) a += mod;
		return *this;
	}
	modint &operator*=(const modint &x){
		a = a * x.a % mod;
		return *this;
	}
	modint &operator/=(const modint &x){
		a = a * (~x).a % mod; 
		return *this;
	}

	friend ostream &operator<<(ostream &os,const modint &x){
		return os << x.a;
	}
	friend istream &operator>>(istream &is,modint &x){
		long long t;
		is >> t;
		x = modint(t);
		return is;
	}

	modint pow(long long x) const{
		modint ret = 1,tmp = a;
		for(;x;tmp *= tmp,x >>= 1){
			if(x & 1) ret *= tmp;
		}
		return ret;
	}
};

signed main(){
	int n,t;
	cin >> n;
	Matrix<modint<2>> A(n);
	for(int i = 0;i < n;i++){
		for(int j = 0;j < n;j++){
			int a;
			cin >> a;
			A[i][j] = a;
		}
	}
	vector<modint<2>> v(n),ans;
	for(int i = 0;i < n;i++) cin >> v[i];
	cin >> t;
	int rnk; bool hasSol;
	tie(ans,hasSol,rnk) = linear_equation(A.pow(t),v);
	if(!hasSol) cout << "none" << endl;
	else if(rnk != n) cout << "ambiguous" << endl;
	else{
		for(int i = 0;i < n;i++) printf("%lld%c",ans[i]," \n"[i == n - 1]);
	}
}



Measured memory_bytes: 5740