#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cctype>
using namespace std;

namespace zyt
{
	template<typename T>
	inline bool read(T &x)
	{
		char c;
		bool f = false;
		x = 0;
		do
			c = getchar();
		while (c != EOF && c != '-' && !isdigit(c));
		if (c == EOF)
			return false;
		if (c == '-')
			f = true, c = getchar();
		do
			x = x * 10 + c - '0', c = getchar();
		while (isdigit(c));
		if (f)
			x = -x;
		return true;
	}
	template<typename T>
	inline void write(T x)
	{
		static char buf[20];
		char *pos = buf;
		if (x < 0)
			putchar('-'), x = -x;
		do
			*pos++ = x % 10 + '0';
		while (x /= 10);
		while (pos > buf)
			putchar(*--pos);
	}
	typedef long long ll;	
	const int N = 1e5 + 10;
	int n, m, x[N], to[N], arr[N], id[N], ans[N];
	ll k;
	void trans(int *a, const int *b)
	{
		static int tmp[N];
		for (int i = 1; i < n; i++)
			tmp[i] = a[b[i]];
		memcpy(a + 1, tmp + 1, sizeof(int[n - 1]));
	}
	int work()
	{
		read(n);
		for (int i = 0; i < n; i++)
			read(x[i]), id[i] = to[i] = i;
		for (int i = n - 1; i > 0; i--)
			x[i] -= x[i - 1];
		read(m), read(k);
		for (int i = 1; i <= m; i++)
			read(arr[i]), --arr[i];
		for (int i = 1; i <= m; i++)
			swap(to[arr[i]], to[arr[i] + 1]);
		while (k)
		{
			if (k & 1)
				trans(id, to);
			trans(to, to);
			k >>= 1;
		}
		ll last;
		write(last = x[0]), putchar('\n');
		for (int i = 1; i < n; i++)
			write(last += x[id[i]]), putchar('\n');
		return 0;
	}
}
int main()
{
	return zyt::work();
}
#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <queue>
#include <map>
#include <set>
#include <iomanip>
#include <bitset>
#include <cassert>
#include <random>
#include <functional>
#include <stack>
#include <iomanip>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>
#include <complex>
#include <cstdio>
#include <list>

//< in.txt > out.txt
using namespace std;
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
const long long MOD = 1e9 + 7;
typedef long long LL;
typedef long double LD;
typedef pair<LL, LL> PLL;
typedef pair<LD, LL> PDL;
typedef pair<LD, LD> PDD;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
//typedef boost::multiprecision::cpp_int bigint;

template<class T>
void in(T& x) {
	cin >> x;
}

template<class T1, class T2>
void in(pair<T1, T2>& p) {
	in(p.first);
	in(p.second);
}

template<class T>
void in(vector<T>& v, LL st = -1, LL en = -1) {
	if (st == -1) {
		st = 0;
		en = v.size() - 1;
	}
	for (LL n = st; n <= en; n++) {
		in(v[n]);
	}
}

VLL mod(VLL& base, LL p) {
	LL N = base.size();
	if (p == 0) {
		VLL res(N);
		for (LL n = 0; n < N; n++)res[n] = n;
		return res;
	}
	if (p == 1)return base;
	VLL ret = mod(base, p / 2);
	VLL res(N);
	for (LL n = 0; n < N; n++) {
		res[n] = ret[ret[n]];
	}
	if (p % 2 == 0)return res;
	for (LL n = 0; n < N; n++) {
		ret[n] = res[base[n]];
	}
	return ret;
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	LL N, K,M;
	cin >> N;
	VLL X(N);
	in(X);
	VLL DX(N - 1);
	for (LL n = 0; n < N - 1; n++) {
		DX[n] = X[n + 1] - X[n];
	}
	cin >> M >> K;
	VLL A(M);
	in(A);
	VLL P(N - 1);
	for (LL n = 0; n < N-1; n++) {
		P[n] = n;
	}
	for (LL m = 0; m < M; m++) {
		LL n = A[m] - 1;
		swap(P[n - 1], P[n]);
	}
	P = mod(P, K);
	VLL res(N);
	res[0] = X[0];
	for (LL n = 1; n < N; n++) {
		res[n] = res[n - 1] + DX[P[n-1]];
	}
	for (LL n = 0; n < N; n++) {
		cout << res[n] << "\n";
	}
	return 0;
}
