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

typedef struct process {
  char name[16];
  int time;
} process;

/* copy the process ** from q to p ** */
void processcpy(process *p, process *q){
  strcpy(p->name, q->name);
  p->time = q->time;
}

/* double-linked linear list of process 
   (to implement process queue) */
typedef struct Node_t {
  process data;
  struct Node_t *next;
  struct Node_t *prev;
} Node;

typedef struct List {
  Node *head;
  Node *tail;
} List;

Node *create_Node(process new_data){
  Node *ret = (Node*)malloc(sizeof(Node));
  if(!ret){
    fprintf(stderr, "could not allocate a node.\n");
    exit(1);
  }
  processcpy(&(ret->data), &new_data);
  ret->prev = NULL;
  ret->next = NULL;
  return ret;
}

int is_nil(const List *l){
  return (l->head == NULL && l->tail == NULL);
}

Node *push_front(List *l, process data){
  Node *new_node = create_Node(data);
  Node *temp;
  if(is_nil(l)){
    l->head = l->tail = new_node;
  }else{
    temp = l->head;
    l->head = temp->prev = new_node;
    new_node->next = temp;
  }
  return new_node;
}

process pop_back(List *l){
  process ret; Node *temp;
  if(is_nil(l)){
    fprintf(stderr, "Error: Couldn't pop from empty list\n");
  }else{
    temp = l->tail;
    processcpy(&ret, &(temp->data));
    if(l->head == l->tail){
      // if l has just one element,
      // l->head and l->tail must be NULL after pop_front.
      l->head = NULL; 
    }
    l->tail = temp->prev;
    free(temp);
  }
  return ret;
}

/* for initializing list */
void init_list(List *l){
  l->head=NULL;
  l->tail=NULL;
}

/* free allocated memories */
void free_list(List *l){
  Node *ptr=l->head, *temp;
  while(ptr!=NULL){
    temp=ptr->next;
    free(ptr);
    ptr=temp;
  }
  init_list(l);
}

int main(void){
  List queue; init_list(&queue);
  int n, q;
  int time=0;
  process p;

  /* read input stream */
  scanf("%d %d", &n, &q);
  for(int i=0; i<n; i++){
    scanf("%s %d", p.name, &(p.time));
    push_front(&queue,p);
  }

  /* Let's simulate scheduling naively! */
  while(!is_nil(&queue)){
    p = pop_back(&queue);
    if(p.time <= q){
      /* process can be finished */
      time += p.time;
      printf("%s %d\n", p.name, time);
    }else{
      /* process cannot be finished, then handle p for q [ms],
	 and then moved it to the end of the queue */
      p.time -= q;
      push_front(&queue,p);
      time += q;
    }
  }

  free_list(&queue);
  return 0;
}

