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

#define MAX_LENGTH_NAME_STR 11
#define MAX_NUM_PROCESS 100000

/*
 * Process
 */
typedef struct {
    char name[MAX_LENGTH_NAME_STR];
    int timeInfo;
} Process;

void copyProcess(Process * p_out, Process in) {
    strcpy(p_out->name, in.name);
    p_out->timeInfo = in.timeInfo;
}
// scanProcess NO NEED
void printProcess(Process process) {
    printf("%s %d", 
        process.name, 
        process.timeInfo
    );
}


/*
 * ProcessQueue
 */
typedef struct {
    Process * processes;
    int head;
    int tail;
    int length;
} ProcessQueue;

void initalizeProcessQueue(ProcessQueue * p_queue, int length) {
    p_queue->processes = (Process *)malloc(length * sizeof(Process));
    // TODO: ^ dangerous!!
    p_queue->head = 0;
    p_queue->tail = 0;
    p_queue->length = length;
}
//void freeProcessQueue(ProcessQueue * p_queue, int length);

// 0 1 2 3 4 ... length-2 length-1
// (length-1) => 0   // looping back to the beginning
//int loopbackIndexIncrement(int index, int length) {
//    if (index + 1 == length) 
//        index = 0;
//    else 
//        index = index + 1;
//    
//    return index;
//};

int isEmpty(ProcessQueue queue) {
    return (queue.tail == queue.head);
}
void dequeue(Process * p_process, ProcessQueue * p_queue) {
//    Process x;// = p_queue->processes[p_queue->head];
    copyProcess(p_process, p_queue->processes[p_queue->head]);
    
    if (p_queue->head + 1 == p_queue->length) 
        p_queue->head = 0;
    else 
        p_queue->head = p_queue->head + 1;
    
//    return x;
//    // is it safe to return struct with string inside?
}
void enqueue(ProcessQueue * p_queue, Process process) {
//    p_queue->processes[p_queue->tail] = process;
    copyProcess(&p_queue->processes[p_queue->tail], process);
    
    if (p_queue->tail + 1 == p_queue->length) 
        p_queue->tail = 0;
    else 
        p_queue->tail = p_queue->tail + 1;
}


void printProcessQueue(ProcessQueue queue) {
    int iProcesses = queue.head; 
    
//    // there is a special reason for using do ... while
//    // since (queue.head == queue.tail) when there are as many processes as the length of the queue!!
//    // But same case for no process at all...
//    // So should we forbit it or allow it?
//    do {
//        printProcess(queue.processes[iProcesses]);
//        printf(" ");
//
//        if (iProcesses + 1 == queue.length) 
//            iProcesses = 0;
//        else 
//            iProcesses = iProcesses + 1;
//        
//    } while (iProcesses != queue.tail);
    while (iProcesses != queue.tail) { // let's forbit it...
        printProcess(queue.processes[iProcesses]);
        printf(" - ");

        if (iProcesses + 1 == queue.length) 
            iProcesses = 0;
        else 
            iProcesses = iProcesses + 1;
    };
    
    printf("\n");
}

void printProcessQueueNewline(ProcessQueue queue) {
    int iProcesses = queue.head; 
    
    while (iProcesses != queue.tail) {
        printProcess(queue.processes[iProcesses]);
        printf("\n");

        if (iProcesses + 1 == queue.length) 
            iProcesses = 0;
        else 
            iProcesses = iProcesses + 1;
    };
}




int main(int argc, char** argv) {
    // scan nProcesses, quantum
    int nProcesses, quantum, timestamp = 0;
    scanf("%d %d ", &nProcesses, &quantum);
    
    // initalizeProcessQueue
    ProcessQueue queue;
    initalizeProcessQueue(&queue, nProcesses + 1);
    
    // process temp
    Process process;
    
    // scan Processes
    for (int iProcesses = 0; iProcesses < nProcesses; iProcesses++) {
        scanf("%s %d ", process.name, &(process.timeInfo));
        enqueue(&queue, process);
    }
    
    // -------------------------------------------------------------------------
    
    // initalizeProcessQueue
    ProcessQueue completeProcess;
    initalizeProcessQueue(&completeProcess, nProcesses + 1);
    
    // do the magic
    for (;;) {
//        printf("timestamp: %d\n", timestamp);
//        printProcessQueue(queue);
        
        dequeue(&process, &queue);
        
        if (process.timeInfo > quantum) {
            timestamp += quantum;
            
            // throw to the end of queue
            process.timeInfo -= quantum;
            enqueue(&queue, process);
        }
        else {
            timestamp += process.timeInfo;
            
            // completing timestamp: current time
            process.timeInfo = timestamp; 
            enqueue(&completeProcess, process);
            if (isEmpty(queue))
                break;
        }
            
    }
    printProcessQueueNewline(completeProcess);

    return (EXIT_SUCCESS);
}




Measured memory_bytes: 3328