#108

#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <deque>
#include <bits/stdc++.h>
//#include "testlib.h"
using namespace std;
#define ll long long
#define pii pair<int,int>
#define qi ios::sync_with_stdio(0)

bool debug=true;

/*    *************************************
	  * Written in New Computer           *
	  * The following code belongs to     *
	  * XiaoGeNintendo of HellHoleStudios *
	  *************************************
*/
template<typename T1,typename T2>ostream& operator<<(ostream& os,pair<T1,T2> ptt){
	os<<ptt.first<<","<<ptt.second;
	return os;
}
template<typename T>ostream& operator<<(ostream& os,vector<T> vt){
	os<<"{";
	for(int i=0;i<vt.size();i++){
		os<<vt[i]<<" ";
	}
	os<<"}";
	return os;
}

/*
	Using Dinic Algorithm to get Maxflow problem
	By XGN from HHS
	Usage: 
	Dinic::addEdge(<start>,<to>,<val>)
	...
	Dinic::getMaxflow(<start>,<sink>)
*/
namespace Dinic{
	const int maxn=100005;
	const int INF=1e9+7;
	
	struct edge{
		int to,val,rev;
		edge(int a,int b,int c){
			to=a;
			val=b;
			rev=c;
		}
	};
	
	vector<edge> nei[maxn];
	int iter[maxn]; //当前弧
	int lv[maxn]; //分层
	
	void addEdge(int from,int to,int val){
		nei[from].push_back(edge(to,val,nei[to].size()));
		nei[to].push_back(edge(from,0,nei[from].size()-1));
	} 
	
	void bfs(int s){
		memset(lv,-1,sizeof(lv));
		queue<int> q;
		lv[s]=0;
		q.push(s);
		
		while(!q.empty()){
			int last=q.front();
			q.pop();
			
			for(int i=0;i<nei[last].size();i++){
				edge& e=nei[last][i];
				if(e.val>0 && lv[e.to]==-1){
					lv[e.to]=lv[last]+1;
					q.push(e.to);
				}
			}
		}
	}
	
	int dfs(int s,int t,int f){
		if(s==t){
			return f;
		}
		
		for(int& i=iter[s];i<nei[s].size();i++){ //当前弧优化！！ 
			edge& e=nei[s][i];
			if(e.val>0 && lv[s]<lv[e.to]){
				int d=dfs(e.to,t,min(f,e.val));
				if(d>0){
					e.val-=d;
					nei[e.to][e.rev].val+=d;
					return d;
				}
			}
		}
		return 0;
	}
	
	int getMaxflow(int s,int t){
		int flow=0;
		while(true){
			bfs(s);
			if(lv[t]<0){
				break;
			}
			
			memset(iter,0,sizeof(iter));
			int f;
			while((f=dfs(s,t,INF))!=0){
				flow+=f;
			}
		}
		
		return flow;
	}
}; 

int n;
int r[55];
int c[55];
int a[55][55];
int ans[55][55];

int main(){
	qi;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>r[i];
	}
	
	ll sm=0;
	for(int i=0;i<n;i++){
		cin>>c[i];
		sm+=c[i];
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			cin>>a[i][j];
		}
	}
	
	int S=2*n;
	int T=2*n+1;
	for(int i=0;i<n;i++){
		Dinic::addEdge(S,i,r[i]);
	}
	for(int i=0;i<n;i++){
		Dinic::addEdge(i+n,T,c[i]);
	}
	
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			Dinic::addEdge(i,j+n,a[i][j]);
		}
	}
	
	int x=Dinic::getMaxflow(S,T);
	if(x!=sm){
		cout<<"NO";
		return 0;
	}
	for(int i=0;i<n;i++){
		for(Dinic::edge& e:Dinic::nei[i]){
			if(e.to>=n && e.to<2*n){
				ans[i][e.to-n]=a[i][e.to-n]-e.val;
			}
		}
	}
	
	cout<<"YES"<<endl;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			cout<<ans[i][j]<<" ";
		}
		cout<<endl;
	}
	
	return 0;
}