#include<iostream>
#include<iomanip>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<vector>
#include<array>
#include<string>
#include<stack>
#include<queue>
#include<algorithm>
#include<cassert>
#include<functional>
#include<random>
#include<complex>
#include<bitset>
#include<chrono>
//#include<boost/multiprecision/cpp_int.hpp>
#define int int64_t
#define uint uint64_t
#define REP(i, a, b) for (int64_t i = (int64_t)(a); i < (int64_t)(b); i++)
#define rep(i, a) REP(i, 0, a)
#define EACH(i, a) for (auto i: a)
#define ITR(x, a) for (auto x = a.begin(); x != a.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define HAS(a, x) (a.find(x) != a.end())
#define Min(x) *min_element(ALL(x))
#define Max(x) *max_element(ALL(x))
#define Unique(L) (L.erase(unique(ALL(L)), L.end()))
#define veccat(v1, v2) std::copy((v2).begin(),(v2).end(),std::back_inserter(v1))
#define intmax (std::numeric_limits<int64_t>::max() / 4)
using namespace std;
//typedef boost::multiprecision::cpp_int bigint;
const double EPS = 1e-9;
const double PI = acos(-1.0);

//vector<int> prod_perm(const vector<int>&a, const vector<int> &b) {
//	//bに置換aを実行して返す。
//	//すなわち、[0..N]→a になるような置換"→"によって、
//	//b→ansとなるようなansを求めて返す。
//
//	assert(a.size() == b.size());
//
//	vector<int>ans(b.size());
//	rep(i, b.size())ans[i] = b[a[i]];
//	return ans;
//}
//
//vector<int> pow_perm(const vector<int>&perm, const int K) {
//	//置換permのK乗を返す。
//
//	if (K == 0) {
//		vector<int>ans(K - 1);
//		rep(i, ans.size())ans[i] = i;
//		return ans;
//	}
//	if (K == 1)return perm;
//
//	vector<int>half = pow_perm(perm, K / 2);
//
//	if (K % 2 == 0)return prod_perm(half, half);
//	else return prod_perm(prod_perm(half, half), perm);
//}
vector<int64_t> prod_permutation(vector<int64_t> v, vector<int64_t> w) {//v○wの計算(先にwで置換、その後vで置換)
	if (v.size() != w.size()) {
		cout << "error" << endl;
		return v;
	}
	else {
		vector<int64_t> ret;
		for (int i = 0; i<v.size(); i++) {
			ret.push_back(v[w[i]]);
		}
		return ret;
	}
}
vector<int64_t> pow_permutation(vector<int64_t> v, int64_t N) {//置換vをN乗した結果を返す。
	if (N % 2 == 0) {
		if (N == 0) {
			vector<int64_t> ret;
			for (int i = 0; i<v.size(); i++) {
				ret.push_back(i);
			}
			return ret;
		}
		else {
			vector<int64_t> ret = pow_permutation(v, N / 2);
			return prod_permutation(ret, ret);
		}
	}
	else {
		if (N == 1) {
			return v;
		}
		else {
			vector<int64_t> ret = pow_permutation(v, (N - 1) / 2);
			return prod_permutation(prod_permutation(v, ret), ret);
		}
	}
}

signed main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	//int N, M, K;
	//cin >> N;
	//vector<int>x(N);
	//rep(i, N)cin >> x[i];
	//cin >> M >> K;
	//vector<int>a(M);
	//rep(i, M)cin >> a[i];
	int64_t N;
	int64_t x[100000];
	int64_t M;
	int64_t K;
	int64_t a[100000];
	cin >> N;
	int64_t dx[100000];
	for (int i = 0; i<N; i++) {
		cin >> x[i];
		if (i != 0) {
			dx[i - 1] = x[i] - x[i - 1];
		}
	}
	cin >> M >> K;
	for (int i = 0; i<M; i++) {
		cin >> a[i];
	}




	vector<int>perm(N - 1);
	rep(i, N - 1)perm[i] = i;

	//rep(i, M)swap(perm[a[i] - 2], perm[a[i] - 1]);
	for (int i = 0; i<M; i++) {
		int64_t tmp = perm[a[i] - 2];
		perm[a[i] - 2] = perm[a[i] - 1];
		perm[a[i] - 1] = tmp;
	}

	auto permK = pow_permutation(perm, K);

	//vector<int>dx(N - 1);
	//rep(i, N - 1)dx[i] = x[i + 1] - x[i];

	int ans = x[0];
	rep(i, N - 1) {
		cout << ans << endl;
		ans += dx[permK[i]];
	}
	cout << ans << endl;


	return 0;
}

Measured memory_bytes: 55156