#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <cstdlib>
int Total_of_element_in_list = 0;																//<-- VARIABLE DE ARITMETICA MODULAR
using namespace std;

//VARIABLE UNIVERSAL PARA ARITMETICA MODULAR



//DEFINE NODOS

struct node
{
	int node_content;
	struct node *previous_position;
	struct node *next_position;
};

struct node *head_list; 											 						    //<-- NODO QUE APUNTA A LA CABEZA

//LISTA DE FUNCIONES

struct node *InsertInCircularlist(struct node *head_list, int element);							// <-- FUNCION QUE LLENA LAS LISTAS CIRCULARES

struct node *PrintCircularList (struct node *head_list); 			 							//<-- FUNCION QUE IMPRIME LAS LISTAS CIRCULARES

struct node *LocateNode(int number_of_moves, struct node *head_list, int flag); 			 	//<-- FUNCION QUE ELIMINA UN NODO DE LAS LISTAS CIRCULARES

struct node *DeleteNodeInCircularlist (struct node *node_to_eliminate, struct node *head_list); //<-- FUNCION QUE ELIMINA UN NODO DE LAS LISTAS CIRCULARES
//--------------------------------------------------------------------------------------------------------------------------//

//FUNCION PRINCIPAL

int main()
{
	struct node *head_list; 						   							//<-- PUNTERO QUE APUNTARA A LA CABEZA DE LA LISTA
	int n;																		//<-- NUMERO DE PERSONAS EN EL CIRCULO
	int k;																		//<-- NUMERO DE MOVIMIENTOS INICIAL ANTES DE ELIMINAR
	int flag = 1;																//<-- BANDERA QUE DECIDIRÁ SI ESTA CONTANDO EN SENTIDO HORARIO O ANTIHORARIO

	while (scanf("%d %d", &n, &k) && n != 0 && k!= 0)
	{
		Total_of_element_in_list= n;
		head_list = NULL; 							       						//<-- EL NODO LISTA COMIENZA APUNTANDO A NULL (HACIA NADA)

		for (int i=1; i<= n; i++)
		{
			head_list = InsertInCircularlist(head_list, i); 				    //<-- LLENA AUTOMATICAMENTE EL NODO
		}

		//PrintCircularList(head_list);
		//printf("LISTA IMPRESA EXITOSAMENTE \n\n"); 							<-- ESTA FUNCION PUEDE SER DESBLOQUEADA PARA VER LA LISTA EN CADA MOMENTO

		while(n != 1)
		{
			head_list=LocateNode(k, head_list, flag);							//<-- LOCALIZA EL NODO MOVIENDOSE DE MANERA HORARIA O ANTIHORARIA
			flag++;
			n--;
		}

		flag = 1;
		printf("%d \n", head_list->node_content);								//<-- RETORNA AL ESTUDIANTE GANADOR DE LA NOTA EN EL EXAMEN


	}

return 0;
}

//--------------------------------------------------------------------------------------------------------------------------//

//INSERT IN CIRCULAR LIST

struct node *InsertInCircularlist (struct node *head_list, int element)
{
	struct node *new_node; 								 	//<-- NODO CON EL QUE NOS MOVEREMOS EN LA LISTA
	new_node=(struct node *)malloc(sizeof(struct node)); 	//<-- DEFINIMOS UN ESPACIO EN LA MEMORIA PARA EL NODO
	new_node->node_content = element;					 	//<-- LE ASIGNAMOS ELEMENT AL CONTENIDO DEL NODO

	if (head_list == NULL)
	{
		new_node -> next_position = new_node;				//<-- EL NEW_NODE SE ENLAZA ASI MISMO DE ADELANTE HACIA ATRAS
		new_node -> previous_position = new_node;			//<-- EL NEW_NODE SE ENLAZA ASÍ MISMO DE ATRAS HACIA ADELANTE
	}
	else
	{
		new_node -> next_position = head_list -> next_position;		//<-- EL NEW_NODE SE ENLAZA HACIA DONDE APUNTA HEAD_LIST
		new_node -> previous_position = head_list;					//<-- EL NEW_NODE SE ENLAZA POR DETRÁS HACIA HEAD_LIST
		head_list -> next_position = new_node;						//<-- EL HEAD_LIST SE ENLAZA HACIA EL NEW_NODE
		new_node -> next_position -> previous_position = new_node;	//<--
	}

	head_list = new_node; 								 	 //<-- AHORA NEW_NODE ES LA CABEZA DE LA LISTA CIRUCLAR

return head_list; 										 	 //<-- RETORNA LA CABEZA DE LA LISTA PARA USARLA EN OTRAS COSAS;
}

//--------------------------------------------------------------------------------------------------------------------------//

//PRINT CIRCULAR LIST

struct node *PrintCircularList(struct node *head_list)
{

	struct node *new_node; 									 //<-- NODO CON EL QUE NOS MOVEREMOS EN LA LISTA
	new_node=(struct node *)malloc(sizeof(struct node));	 //<-- DEFINIMOS UN ESPACIO EN LA MEMORIA PARA EL NODO
	new_node= head_list;

	if (head_list != NULL)
	{
		do
		{
			printf("%d ", new_node -> node_content);		 // <-- IMPRIME EL CONTENIDO DEL NODO QUE ESTAMOS MOVIENDO
			new_node = new_node -> next_position;			 // <-- MUEVE LA DIRECCIÓN DEL NODO HACIA EL SIGUIENTE DEL QUE ESTÁ APUNTANDO
		} while (new_node != head_list);
	}
	else
		printf("THE LIST IS EMPTY\n");

printf("\n"); 											 	 // <-- DA UN SALTO DE LINEA PARA NO CONFUNDIR DATOS

return head_list;
}

//--------------------------------------------------------------------------------------------------------------------------//

//LOCATE NODE

struct node *LocateNode (int number_of_moves, struct node *head_list, int flag)
{
	int number_of_moves_copy;												//<-- CREA UNA COPIA PARA SER EVALUADA POR ARITMETICA MODULAR
	number_of_moves_copy = number_of_moves % Total_of_element_in_list;		//<-- EVALUA LA COPIA

	if (number_of_moves_copy == 0)
		number_of_moves_copy = number_of_moves;								//<-- DEVUELVE EL VALOR ORIGINAL SI ESTA HA PASADO EL FILTRO


	if (flag % 2 != 0)														//<-- MOVIMIENTO EN SENTIDO DE LAS MANECILLAS DEL RELOJ
	{
		for (int i=1; i<number_of_moves_copy; i++)
			head_list = head_list -> next_position;							//<-- ACCION DE MOVIMIENTO EN EL CIRCULO

		head_list = DeleteNodeInCircularlist (head_list, head_list);		//<-- ELIMINA EL "ESTUDIANTE SELECCIONADO"
		Total_of_element_in_list--;
	}
	else 																	//<-- MOVIMIENTO EN CONTRA DE LAS MANECILLAS DEL RELOJ
	{
		for (int i=1; i<number_of_moves_copy; i++)
			head_list = head_list -> previous_position;						//<-- ACCION DE MOVIMIMIENTO EN EL CIRCULO

		head_list = DeleteNodeInCircularlist (head_list, head_list);		//<-- ELIMINA EL "ESTUDIDANTE SELECCIONADO"
		Total_of_element_in_list--;
		head_list = head_list -> previous_position;							//<-- POSICIONA EL NUEVO ESTUDIANTE PARA COMENZAR A CONTAR DE NUEVO
	}
return head_list;															//<-- RETORNA AL GANADOR
}

//--------------------------------------------------------------------------------------------------------------------------//

//DELETE NODE IN CIRCULAR LIST

struct node *DeleteNodeInCircularlist (struct node *node_to_eliminate, struct node *head_list)
{
	struct node *actual_node;												// <-- NODO CON EL QUE NOS MOVEREMOS
	if (head_list == NULL)
		printf("THE LIST IS EMPTY\n");
	else
	{

		if (head_list == head_list -> next_position)						//<-- SI LA CABEZA SE APUNTA A SÍ MISMA
		{
			free(head_list);												//<-- LIBERA EL NODO HEAD_LIST
			head_list = NULL;												//<-- DEJA AL APUNTADOR APUNTANDO A LA NADA
		}
		else
		{
			actual_node = node_to_eliminate -> next_position;						//<-- QUE EL ACTUAL_NODE SE MUEVA HACIA EL NODO DONDE APUNTA NODE_TO_ELIMINATE
			node_to_eliminate -> next_position = actual_node -> next_position;		//<-- QUE EL NODE_TO_ELIMINATE APUNTE A DONDE APUNTA EL ACTUAL_NODE
			actual_node -> next_position -> previous_position = node_to_eliminate;	//<-- QUE EL NODO AL QUE APUNTA ACTUAL_NODE APUNTE POR DETRAS HACIA EL ADENALTE DEL NODE_TO_ELIMINATE
			if (head_list == actual_node)
			{
				head_list = node_to_eliminate;
			}
			free (actual_node);
		}
	}
return head_list;
}