#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
void solve(bool);
void precalc();
clock_t start;
int main() {
  start = clock();
  int t = 1;
  cout.sync_with_stdio(0);
  cin.tie(0);
  precalc();
  cout.precision(10);
  cout << fixed;
  int testNum = 1;
  while (t--) {
    solve(true);
  }
  cout.flush();
  return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
  if (!w) return 1 % mod;
  if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
  return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
  while (w) {
    q %= w;
    swap(q, w);
  }
  return q;
}
template <typename T>
T lcm(T q, T w) {
  return q / gcd(q, w) * w;
}
template <typename T>
void make_unique(vector<T>& a) {
  sort(a.begin(), a.end());
  a.erase(unique(a.begin(), a.end()), a.end());
}
template <typename T>
void relax_min(T& cur, T val) {
  cur = min(cur, val);
}
template <typename T>
void relax_max(T& cur, T val) {
  cur = max(cur, val);
}
void precalc() {}
struct Parent {
  int last_par = -1;
  int last_coord = -1;
  int shot_coord = -1;
  Parent() : last_par(-1), last_coord(-1), shot_coord(-1) {}
  Parent(int last_par, int last_coord, int shot_coord)
      : last_par(last_par), last_coord(last_coord), shot_coord(shot_coord) {}
};
const int C = 3000500;
int has[2][C];
int dp[2][C];
Parent pred[2][C];
int next_uk[2][C];
void solve(bool read) {
  int n, m[2], t;
  if (read) {
    cin >> n >> m[0] >> m[1] >> t;
  } else {
    n = 1000000000;
    m[0] = 500000;
    m[1] = 500000;
    t = 2;
  }
  vector<int> all_coords;
  vector<vector<int>> coords(2);
  for (int i = 0; i < 2; ++i) {
    for (int j = 0; j < m[i]; ++j) {
      int cur;
      if (read) {
        cin >> cur;
      } else {
        cur = 1000 * (j + 1) + 500 * (i + 1);
      }
      coords[i].push_back(cur);
      all_coords.push_back(cur);
      if (cur < n) {
        all_coords.push_back(cur + 1);
      }
      if (cur > 0) {
        all_coords.push_back(cur - 1);
      }
    }
    sort(coords[i].begin(), coords[i].end());
    coords[i].erase(unique(coords[i].begin(), coords[i].end()),
                    coords[i].end());
  }
  all_coords.push_back(0);
  sort(all_coords.begin(), all_coords.end());
  all_coords.erase(unique(all_coords.begin(), all_coords.end()),
                   all_coords.end());
  for (int i = 0; i < 2; ++i) {
    for (int j = 0; j < all_coords.size(); ++j) {
      dp[i][j] = -1;
      has[i][j] = false;
    }
  }
  for (int i = 0; i < 2; ++i) {
    for (int& x : coords[i]) {
      x = lower_bound(all_coords.begin(), all_coords.end(), x) -
          all_coords.begin();
      has[i][x] = true;
    }
  }
  dp[0][0] = 0;
  int last_par = -1, last_coord = -1;
  for (int i = 0; i < 2; ++i) {
    for (int j = 0; j < all_coords.size(); ++j) {
      next_uk[i][j] = -1;
    }
  }
  for (int i = 0; i < 2; ++i) {
    int last = -1;
    for (int j = (int)all_coords.size() - 1; j >= 0; --j) {
      next_uk[i][j] = last;
      if (has[i][j]) {
        last = j;
      }
    }
  }
  vector<int> cur_dp(2, -1);
  for (int i = 0; i < all_coords.size(); ++i) {
    cur_dp.assign(2, -1);
    for (int j = 0; j < 2; ++j) {
      if (!has[j][i]) {
        cur_dp[j] = dp[j][i];
      } else {
        if (dp[j][i] > t) {
          cur_dp[j] = dp[j][i] - t;
        }
      }
    }
    for (int j = 0; j < 2; ++j) {
      if (cur_dp[j] != -1 && !has[j ^ 1][i]) {
        if (cur_dp[j ^ 1] < min(cur_dp[j], t)) {
          pred[j ^ 1][i] = {j, i, -1};
          cur_dp[j ^ 1] = min(cur_dp[j], t);
        }
      }
    }
    for (int j = 0; j < 2; ++j) {
      if (cur_dp[j] == -1) {
        continue;
      }
      int it = next_uk[j][i];
      if (it == -1) {
        last_par = j;
        last_coord = i;
      } else {
        if (dp[j][it] < cur_dp[j] + all_coords[it] - all_coords[i]) {
          dp[j][it] = cur_dp[j] + all_coords[it] - all_coords[i];
          pred[j][it] = {j, i, all_coords[i] + t - cur_dp[j]};
        }
      }
      if (i + 1 < all_coords.size() && !has[j][i + 1]) {
        if (dp[j][i + 1] < cur_dp[j] + all_coords[i + 1] - all_coords[i]) {
          dp[j][i + 1] = cur_dp[j] + all_coords[i + 1] - all_coords[i];
          pred[j][i + 1] = {j, i, -1};
        }
      }
    }
  }
  if (last_par == -1) {
    cout << "No\n";
    return;
  }
  cout << "Yes\n";
  vector<pair<int, int>> shots;
  vector<int> swaps;
  int cnt = 0;
  while (last_par != 0 || last_coord != 0) {
    ++cnt;
    assert(cnt < 3e6);
    auto pr = pred[last_par][last_coord];
    if (pr.shot_coord != -1) {
      shots.push_back({last_par, pr.shot_coord});
    }
    if (pr.last_par != last_par) {
      swaps.push_back(all_coords[pr.last_coord]);
    }
    last_par = pr.last_par;
    last_coord = pr.last_coord;
  }
  reverse(shots.begin(), shots.end());
  reverse(swaps.begin(), swaps.end());
  if (read) {
    cout << swaps.size() << endl;
    for (int x : swaps) {
      cout << x << " ";
    }
    cout << endl;
    cout << shots.size() << endl;
    for (auto item : shots) {
      cout << item.second << " " << item.first + 1 << "\n";
    }
  }
}
