class Node:

    def __init__(self,v):

        self.v = v

        self.next = None



class Queue:

    def __init__(self):

        self.head = None

        self.tail = None

        self.size = 0



    def enqueue(self,v):

        self.size += 1

        n = Node(v)

        if self.tail == None:

            self.tail = n

        else:

            self.tail.next = n

            self.tail = n

        if self.head == None:

            self.head = self.tail

    def dequeue(self):

        if self.size == 0:

            print('underflow')

            exit()

        self.size -= 1

        v = self.head.v

        self.head = self.head.__next__

        if self.head == None:

            self.tail = None

        return v



#class Queue:

#    def __init__(self,l):

#        self.values = []

#        self.l = l

#        for _ in range(l):

#            self.values.append(None)

#        self.head = 0

#        self.tail = 0

#    def inc(self,n):

#        if n+1 >= self.l:

#            return 0

#        else:

#            return n+1

#    def enqueue(self,v):

#        if self.inc(self.head) == self.tail:

#            print 'overflow'

#            exit()

#        self.values[self.head] = v

#        self.head = self.inc(self.head)

#    def dequeue(self):

#        if self.head == self.tail:

#            print 'underflow'

#            exit()

#        v = self.values[self.tail]

#        self.tail = self.inc(self.tail)

#        return v

#    def size(self):

#        if self.head >= self.tail:

#            return self.head-self.tail

#        else:

#            self.head + (self.l-self.tail)



n,q = list(map(int,input().split(' ')))

queue = Queue()

for _ in range(n):

    n,t = input().split(' ')

    t = int(t)

    queue.enqueue((n,t))



c = 0

while queue.size>0:

    n,t = queue.dequeue()

    if t <= q:

        c += t

        print(n,c)

    else:

        queue.enqueue((n,t-q))

        c += q
class Queue:

    def __init__(self, n):

        self.values = [None]*n

        self.n = n

        self.s = 0

        self.t = 0



    def next(self, p):

        ret = p+1

        if ret >= self.n:

            ret = 0

        return ret



    def enqueue(self, x):

        if self.next(self.s) == self.t:

            raise Exception("Overflow")

        self.values[self.s] = x

        self.s = self.next(self.s)



    def dequeue(self):

        if self.s == self.t:

            raise Exception("Underflow")

        ret = self.values[self.t]

        self.t = self.next(self.t)

        return ret



n, q = list(map(int, input().split(' ')))

queue = Queue(n+1)

for _ in range(n):

    name, time = input().split(' ')

    time = int(time)

    queue.enqueue((name, time))



completed = []

cur = 0

while len(completed) < n:

    name, time = queue.dequeue()

    res = time-q

    if res <= 0:

        cur += time

        completed.append((name, cur))

    else:

        cur += q

        queue.enqueue((name, res))



for name, time in completed:

    print(name, time)
class Node:
    def __init__(self, v):
        self.v = v
        self.next = None


class Queue:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def enqueue(self, v):
        self.size += 1
        n = Node(v)
        if self.tail == None:
            self.tail = n
        else:
            self.tail.next = n
            self.tail = n
        if self.head == None:
            self.head = self.tail

    def dequeue(self):
        if self.size == 0:
            print("underflow")
            exit()
        self.size -= 1
        v = self.head.v
        self.head = self.head.__next__
        if self.head == None:
            self.tail = None
        return v


# class Queue:
#    def __init__(self,l):
#        self.values = []
#        self.l = l
#        for _ in range(l):
#            self.values.append(None)
#        self.head = 0
#        self.tail = 0
#    def inc(self,n):
#        if n+1 >= self.l:
#            return 0
#        else:
#            return n+1
#    def enqueue(self,v):
#        if self.inc(self.head) == self.tail:
#            print 'overflow'
#            exit()
#        self.values[self.head] = v
#        self.head = self.inc(self.head)
#    def dequeue(self):
#        if self.head == self.tail:
#            print 'underflow'
#            exit()
#        v = self.values[self.tail]
#        self.tail = self.inc(self.tail)
#        return v
#    def size(self):
#        if self.head >= self.tail:
#            return self.head-self.tail
#        else:
#            self.head + (self.l-self.tail)
n, q = list(map(int, input().split(" ")))
queue = Queue()
for _ in range(n):
    n, t = input().split(" ")
    t = int(t)
    queue.enqueue((n, t))
c = 0
while queue.size > 0:
    n, t = queue.dequeue()
    if t <= q:
        c += t
        print(n, c)
    else:
        queue.enqueue((n, t - q))
        c += q

class Queue:
    def __init__(self, n):
        self.values = [None] * n
        self.n = n
        self.s = 0
        self.t = 0

    def next(self, p):
        ret = p + 1
        if ret >= self.n:
            ret = 0
        return ret

    def enqueue(self, x):
        if self.next(self.s) == self.t:
            raise Exception("Overflow")
        self.values[self.s] = x
        self.s = self.next(self.s)

    def dequeue(self):
        if self.s == self.t:
            raise Exception("Underflow")
        ret = self.values[self.t]
        self.t = self.next(self.t)
        return ret


n, q = list(map(int, input().split(" ")))
queue = Queue(n + 1)
for _ in range(n):
    name, time = input().split(" ")
    time = int(time)
    queue.enqueue((name, time))
completed = []
cur = 0
while len(completed) < n:
    name, time = queue.dequeue()
    res = time - q
    if res <= 0:
        cur += time
        completed.append((name, cur))
    else:
        cur += q
        queue.enqueue((name, res))
for name, time in completed:
    print(name, time)

-class Node: -    def __init__(self, v): -        self.v = v -        self.next = None +class Queue: +    def __init__(self, n): +        self.values = [None] * n +        self.n = n +        self.s = 0 +        self.t = 0 + +    def next(self, p): +        ret = p + 1 +        if ret >= self.n: +            ret = 0 +        return ret + +    def enqueue(self, x): +        if self.next(self.s) == self.t: +            raise Exception("Overflow") +        self.values[self.s] = x +        self.s = self.next(self.s) + +    def dequeue(self): +        if self.s == self.t: +            raise Exception("Underflow") +        ret = self.values[self.t] +        self.t = self.next(self.t) +        return ret -class Queue: -    def __init__(self): -        self.head = None -        self.tail = None -        self.size = 0 - -    def enqueue(self, v): -        self.size += 1 -        n = Node(v) -        if self.tail == None: -            self.tail = n -        else: -            self.tail.next = n -            self.tail = n -        if self.head == None: -            self.head = self.tail - -    def dequeue(self): -        if self.size == 0: -            print("underflow") -            exit() -        self.size -= 1 -        v = self.head.v -        self.head = self.head.__next__ -        if self.head == None: -            self.tail = None -        return v - - -# class Queue: -#    def __init__(self,l): -#        self.values = [] -#        self.l = l -#        for _ in range(l): -#            self.values.append(None) -#        self.head = 0 -#        self.tail = 0 -#    def inc(self,n): -#        if n+1 >= self.l: -#            return 0 -#        else: -#            return n+1 -#    def enqueue(self,v): -#        if self.inc(self.head) == self.tail: -#            print 'overflow' -#            exit() -#        self.values[self.head] = v -#        self.head = self.inc(self.head) -#    def dequeue(self): -#        if self.head == self.tail: -#            print 'underflow' -#            exit() -#        v = self.values[self.tail] -#        self.tail = self.inc(self.tail) -#        return v -#    def size(self): -#        if self.head >= self.tail: -#            return self.head-self.tail -#        else: -#            self.head + (self.l-self.tail) -queue = Queue() +queue = Queue(n + 1) -    n, t = input().split(" ") -    t = int(t) -    queue.enqueue((n, t)) -c = 0 -while queue.size > 0: -    n, t = queue.dequeue() -    if t <= q: -        c += t -        print(n, c) +    name, time = input().split(" ") +    time = int(time) +    queue.enqueue((name, time)) +completed = [] +cur = 0 +while len(completed) < n: +    name, time = queue.dequeue() +    res = time - q +    if res <= 0: +        cur += time +        completed.append((name, cur)) -        queue.enqueue((n, t - q)) -        c += q +        cur += q +        queue.enqueue((name, res)) +for name, time in completed: +    print(name, time)