import os
import sys
from io import BytesIO, IOBase
 
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        import os
        self.os = os
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            self.os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
 
import time
start_time = time.time()

import collections as col
import math
from functools import reduce

def getInts():
    return [int(s) for s in input().split()]

def getInt():
    return int(input())

def getStrs():
    return [s for s in input().split()]

def getStr():
    return input()

def listStr():
    return list(input())

import heapq

MOD = 10**9+7

"""
We need to work out which values 0, 1, 2, 3, ..., X-1 we have if we mod all the numbers
We need to know how many of each we have
The MEX is min missing one + x*number_complete_cycles
Sounds like a heap / dictionary
We need tuples (count_mod_x, mod_x), and we need to know the minimum value of count_mod_x and the min value of mod_x at that level
Segment tree, where each level is the min of the counts, and in the case of a tie, the min of the mods
"""

def solve():
    def build(arr) : 
        for i in range(n) :
            tree[n + i] = [0,i]
        for i in range(n - 1, 0, -1) :
            a, b = tree[i << 1], tree[i << 1 | 1]
            if a[0] < b[0]:
                tree[i] = a
            elif a[0] > b[0]:
                tree[i] = b
            else:
                tree[i] = [a[0],min(a[1],b[1])]
      
    def updateTreeNode(p):
        tree[p + n][0] += 1
        i = p + n
        
        while i > 1:
            i >>= 1
            a, b = tree[i << 1], tree[i << 1 | 1]
            if a[0] < b[0]:
                tree[i] = a
            elif a[0] > b[0]:
                tree[i] = b
            else:
                tree[i] = [a[0],min(a[1],b[1])]
    
    Q, n = getInts()
    tree = [0]*(2*n)
    A = [0]*n
    build(A)
    for q in range(Q):
        updateTreeNode(getInt()%n)
        print(tree[1][0]*n+tree[1][1])
    return
            
            
    
#for _ in range(getInt()):    
solve()

 
