#include <stdio.h>
#include <iostream>
#include <stdlib.h>

// getchar_unlocked or getchar
#define getChar getchar_unlocked
// putchar_unlocked or putchar
#define putChar putchar_unlocked


inline void wczytajLiczbe(unsigned int *liczba)
{
	register char c = 0;
	while(c < 33)
		c=getChar();

	(*liczba) = 0;
	while(c > 32)
	{
		(*liczba) = (*liczba) * 10ULL + (c - 48);
		c = getChar();
	}
}

inline void wyswietlLiczbeRekurencja(unsigned int liczba)
{
	if(liczba > 0)
	{
		wyswietlLiczbeRekurencja(liczba / 10);
		putChar(liczba % 10 + 48);
	}
}

inline void wyswietlLiczbe(unsigned int liczba)
{
	putChar(32); // znak 'spacja', oddziela liczby

	if(liczba > 0)
	{
		wyswietlLiczbeRekurencja(liczba);
	}
	else
	{
		putChar(liczba % 10 + 48);
	}
}

int main()
{
	register unsigned int rozmiarTablicy = 1024;
	register unsigned int iloscElementow = 0;
	register unsigned int iloscRund;
	
	unsigned int* tablicaLiczb = (unsigned int*) malloc(rozmiarTablicy * sizeof(unsigned int));

	wczytajLiczbe(&iloscRund);
	if(!feof(stdin))
	{
		unsigned int zmiennaTymczasowa;
		fscanf(stdin, "%u", &zmiennaTymczasowa);
		tablicaLiczb[iloscElementow] = zmiennaTymczasowa;
		iloscElementow++;
		unsigned int aktualnaPozycja = 0;
		while(!feof(stdin))
		{
			if(iloscElementow+1 >= rozmiarTablicy)
			{
				// jesli ilosc elementow rowna sie rozmiarowi tablicy, to powieksz tablice dwukrotnie
				rozmiarTablicy = rozmiarTablicy * 2;
				tablicaLiczb = (unsigned int*) realloc(tablicaLiczb, rozmiarTablicy * sizeof(unsigned int));
			}

			wczytajLiczbe(&zmiennaTymczasowa);
			tablicaLiczb[iloscElementow] = zmiennaTymczasowa;
			iloscElementow++;
		}
		register unsigned int wartoscAktualnegoElementu = tablicaLiczb[aktualnaPozycja];

		register unsigned int wartoscElementuOJakaNalezyPrzesunac;
		for(int r = 0; r < iloscRund; r++)
		{
			if(wartoscAktualnegoElementu % 2 == 0)
			{
				// parzysta = operacja R
				// usun nastepny element, a nastepnie przesun o wartosc nastepnego [usuwanego] elementu
				if(aktualnaPozycja == iloscElementow-1)
				{
					// aktualny to ostatni element tabeli, nalezy usunac pierwszy
					wartoscElementuOJakaNalezyPrzesunac = tablicaLiczb[0];
					memcpy(tablicaLiczb, tablicaLiczb+1, iloscElementow * sizeof(int));
					aktualnaPozycja--;
				}
				else
				{
					wartoscElementuOJakaNalezyPrzesunac = tablicaLiczb[aktualnaPozycja+1];
					memcpy(tablicaLiczb+aktualnaPozycja+1, tablicaLiczb+aktualnaPozycja+2, (iloscElementow-aktualnaPozycja+1) * sizeof(int));
				}
				iloscElementow--;
			}
			else
			{
				// nie parzysta = operacja X
				// wstaw nastepny element o wartosci aktualnego elementu minus 1, a nastepnie przesun o wartosc aktualnego elementu
				wartoscElementuOJakaNalezyPrzesunac = wartoscAktualnegoElementu;
				if(iloscElementow+1 >= rozmiarTablicy)
				{
					// jesli ilosc elementow rowna sie rozmiarowi tablicy, to powieksz tablice dwukrotnie
					rozmiarTablicy = rozmiarTablicy * 2;
					tablicaLiczb = (unsigned int*) realloc(tablicaLiczb, rozmiarTablicy * sizeof(unsigned int));
				}
				memcpy(tablicaLiczb+aktualnaPozycja+2, tablicaLiczb+aktualnaPozycja+1, (iloscElementow-aktualnaPozycja+1) * sizeof(int));
				tablicaLiczb[aktualnaPozycja+1] = wartoscElementuOJakaNalezyPrzesunac - 1;

				iloscElementow++;
			}

			if(iloscElementow > 0)
			{
				wartoscElementuOJakaNalezyPrzesunac = wartoscElementuOJakaNalezyPrzesunac % iloscElementow;
				aktualnaPozycja = (aktualnaPozycja + wartoscElementuOJakaNalezyPrzesunac) % iloscElementow;
				wartoscAktualnegoElementu = tablicaLiczb[aktualnaPozycja];
			}
			else
			{
				break;
			}
		}
		if(iloscElementow > 0)
		{
			fprintf(stdout, "%u", tablicaLiczb[aktualnaPozycja]);
			for(int i = aktualnaPozycja+1; i < iloscElementow; ++i)
			{
				wyswietlLiczbe(tablicaLiczb[i]);
			}
			for(int i = 0; i < aktualnaPozycja; ++i)
			{
				wyswietlLiczbe(tablicaLiczb[i]);
			}
		}
		else
		{
			fprintf(stdout, "-1");
		}
	}
	else
	{
		fprintf(stdout, "-1");
	}

	return 0;
}