#include <iostream>
#include <random>
#include <math.h>

template<typename T>
void Swap(T& a, T& b) {
  T temp = a;
  a = b;
  b = temp;
}

template <typename T>
int Partition(T* arr, int left_border, int right_border) {
  int pivot_index = right_border - 1;
  int piece_size = right_border - left_border;

  int random_index = left_border + std::rand() % piece_size;
  Swap(arr[random_index], arr[pivot_index]);

  int i = left_border;
  int j = left_border;
  while (j < pivot_index) {
    if (arr[j] > arr[pivot_index]) {
      ++j;
    } else {
      Swap(arr[i], arr[j]);
      ++i;
      ++j;
    }
  }

  Swap(arr[i], arr[pivot_index]);

  return i;
}

template <typename T>
T GetKthOrderStatistic(T* arr, int size, int k) {
  int left_border = 0;
  int right_border = size;
  int pivot_index = -1;

  while (k != pivot_index) {
    pivot_index = Partition(arr, left_border, right_border);
    if (k < pivot_index) {
      right_border = pivot_index;
    } else if (k > pivot_index) {
      left_border = pivot_index + 1;
    }
  }

  return arr[k];
}

template <typename T>
T* GenerateSequence(T a0, T a1, int size) {
  T* arr = new T [size];

  arr[0] = a0;
  arr[1] = a1;
  for (int i = 2; i < size; ++i) {
    arr[i] = (arr[i - 1] * 123 + arr[i - 2] * 45) % (static_cast<int>(pow(10, 7)) + 4321);
  }

  return arr;
}

template <typename T>
void DeleteArray(T* arr) {
  delete[] arr;
}

int main() {
  int arr_size = 0;
  int index_for_order_statistic = 0;
  int a0 = 0;
  int a1 = 0;

  std::cin >> arr_size >> index_for_order_statistic >> a0 >> a1;

  int* arr = GenerateSequence(a0, a1, arr_size);

  std::cout << GetKthOrderStatistic(arr, arr_size, index_for_order_statistic - 1);

  DeleteArray(arr);

  return 0;
}