#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
class Ruler {
 public:
  template <typename Iterator>
  Ruler(Iterator begin, Iterator end) : marks_(begin, end) {}
  void CanMeasure(int distance, bool &can_measure, int &left_mark,
                  int &right_mark) {
    for (int left = 0; left < marks_.size(); ++left) {
      int to_search = distance + marks_[left];
      int found_place = BinarySearch(to_search, left, marks_.size());
      if (found_place != -1) {
        left_mark = left;
        right_mark = found_place;
        can_measure = true;
        return;
      }
    }
    can_measure = false;
  }
  void CanMeasureRight(int distance, bool &can_measure, int &left_mark,
                       int &right_mark) {
    for (int left = marks_.size() - 1; left >= 0; --left) {
      int to_search = distance + marks_[left];
      int found_place = BinarySearch(to_search, left, marks_.size());
      if (found_place != -1) {
        left_mark = left;
        right_mark = found_place;
        can_measure = true;
        return;
      }
    }
    can_measure = false;
  }
  int BinarySearch(int value, int left_bound, int right_bound) {
    while (left_bound < right_bound - 1) {
      int middle = (left_bound + right_bound) / 2;
      if (marks_[middle] == value) {
        return middle;
      } else if (marks_[middle] > value) {
        right_bound = middle;
      } else {
        left_bound = middle;
      }
    }
    return -1;
  }

 private:
  vector<int> marks_;
};
vector<int> GetExtraMarksToMeasure(const vector<int> &marks, int girl_distance,
                                   int boy_distance) {
  Ruler ruler(marks.begin(), marks.end());
  int left_mark, right_mark;
  bool can_measure_boy, can_measure_girl, can_measure_sum, can_measure_diff;
  ruler.CanMeasure(girl_distance, can_measure_girl, left_mark, right_mark);
  ruler.CanMeasure(boy_distance, can_measure_boy, left_mark, right_mark);
  if (can_measure_boy && can_measure_girl) {
    return {};
  }
  if (can_measure_girl) {
    return {boy_distance};
  }
  if (can_measure_boy) {
    return {girl_distance};
  }
  ruler.CanMeasure(girl_distance + boy_distance, can_measure_sum, left_mark,
                   right_mark);
  if (can_measure_sum) {
    return {marks[left_mark] + girl_distance};
  }
  int length = *marks.rbegin();
  ruler.CanMeasure(boy_distance - girl_distance, can_measure_diff, left_mark,
                   right_mark);
  if (can_measure_diff) {
    if (length - marks[right_mark] >= girl_distance) {
      return {marks[right_mark] + girl_distance};
    }
  }
  ruler.CanMeasureRight(boy_distance - girl_distance, can_measure_diff,
                        left_mark, right_mark);
  if (can_measure_diff) {
    if (marks[left_mark] >= girl_distance) {
      return {marks[left_mark] - girl_distance};
    }
  }
  return {girl_distance, boy_distance};
}
int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  size_t marks_count, length, girl_distance, boy_distance;
  cin >> marks_count >> length >> girl_distance >> boy_distance;
  vector<int> marks(marks_count);
  for (size_t i = 0; i < marks_count; ++i) {
    cin >> marks[i];
  }
  vector<int> extra_marks =
      GetExtraMarksToMeasure(marks, girl_distance, boy_distance);
  cout << extra_marks.size() << endl;
  for (int mark : extra_marks) {
    cout << mark << ' ';
  }
  cout << endl;
  return 0;
}
