There are various parking lots such as three-dimensional type and tower type in the city to improve the utilization efficiency of the parking lot. In some parking lots, a "two-stage parking device" as shown in the figure is installed in one parking space to secure a parking space for two cars. This two-stage parking device allows one to be placed on an elevating pallet (a flat iron plate on which a car is placed) and parked in the upper tier, and the other to be parked in the lower tier.

In a parking lot that uses such a two-stage parking device, it is necessary to take out the car parked in the lower tier and dismiss it each time to put in and out the car in the upper tier, so be sure to manage it. Keeps the key to the parked car and puts it in and out as needed.

| <image>
--- | ---

Tsuruga Parking Lot is also one of the parking lots equipped with such a two-stage parking device, but due to lack of manpower, the person who cannot drive the car has become the manager. Therefore, once the car was parked, it could not be moved until the customer returned, and the car in the upper tier could not be put out until the owner of the car in the lower tier returned.

Create a program that meets the rules of the Tsuruga parking lot to help the caretaker who has to handle the cars that come to park one after another.

Tsuruga parking lot facilities

* There is one or more parking spaces, all equipped with a two-stage parking device.
* Each parking space is numbered starting from 1.
* Initially, it is assumed that no car is parked in the parking lot.



Tsuruga parking lot adopts the following rules.

When to stop the car

* The caretaker will be informed of the parking time of the car to be parked.
* We will park first in the parking space where no car is parked.
* If there is no parking space where no car is parked, park in an empty parking space. However, if there are multiple such parking spaces, follow the procedure below to park.
1. If the remaining parking time of a parked car is longer than the parking time of the car you are trying to park, park in the parking space with the smallest difference.
2. If the remaining parking time of any parked car is less than the parking time of the car you are trying to park, park in the parking space with the smallest difference.
* If the car is full (no parking space available), the car you are trying to park will wait in turn until the parking space is available. As soon as it becomes available, we will park in order from the first car we were waiting for.



* Under each condition, if there are multiple applicable parking spaces, the parking space number will be the smallest. In addition, if there are cars leaving at the same time, parking will start after all the cars leaving at the same time, and as long as there are cars waiting, the cars that can be parked will be parked at the same time.

When the car leaves

* Cars that have passed the parking time notified by the manager will be shipped.
* If there are cars in multiple parking spaces that have passed the parking time at the same time, the car with the smallest parking space number will be shipped first.
* If the parking time of the car parked in the upper row has expired, you will have to wait until the car in the lower row leaves the garage. The upper car will be delivered at the same time after the lower car is delivered.



The figure below shows an example of how to park at Tsuruga Parking Lot. In this example, the number of parking spaces is 3, and cars B to E are already parked. Consider that car A, which has a parking time of 70 minutes, arrives there. You cannot park because two cars are already parked in parking space 3, and you will have to park in either parking space 1 or parking space 2 that is still vacant. Car B parked in parking space 1 has 50 minutes remaining and car C parked in parking space 2 has 22 minutes remaining, both of which are less than car A's parking time, so car A's parking Park in parking space 1 where car B, which has a smaller time difference, is parked. As a result, car B, which was parked earlier, will be in the upper row.

<image>


Create a program that inputs the number of parking spaces m, the number of cars parked n, and the parking time t of each car, and outputs the car reference numbers in the order in which they come out of the parking lot. However, cars are assigned an integer reference number starting with 1 in the order of input, and cars will come to park one by one every 10 minutes in the order of the reference number.



Input

A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:


m n
t1
t2
::
tn


The first line gives the number of two-stage parking devices m (1 ≤ m ≤ 10) and the number of cars parked n (1 ≤ n ≤ 100). The next n lines are given the parking time ti (1 ≤ ti ≤ 120) for the i-th car.

The number of datasets does not exceed 20.

Output

The reference number of the car is output to one line in the order of coming out of the parking lot for each data set. Please output the reference numbers separated by blanks.

Example

Input

3 5
90
52
82
84
70
2 4
10
30
40
60
0 0


Output

2 5 1 4 3
1 2 4 3

Difficulty: UNKNOWN_DIFFICULTY

Solutions:
from collections import deque

def out(time, parking):
	x = len(parking)
	outs = []
	for i in range(x):
		for j in range(2):
			if parking[i][j] != None:
				parking[i][j][0] -= time
	for i in range(x):
		c1 = parking[i][0]
		c2 = parking[i][1]
		if c1 != None and c2 != None:
			if c1[0] <= 0 and c2[0] <= 0:
				outs.append([c2[1], c1[1]])
				parking[i][0] = None
				parking[i][1] = None
			elif c2[0] <= 0:
				outs.append([c2[1]])
				parking[i][1] = None
		elif c1 != None:
			if c1[0] <= 0:
				outs.append([c1[1]])
				parking[i][0] = None
		elif c2 != None:
			if c2[0] <= 0:
				outs.append([c2[1]])
				parking[i][1] = None
	lst = []
	for l in outs:
		lst += l
	return lst

def into(num, time, parking):
	x = len(parking)
	times = []
	for i in range(x):
		if parking[i] == [None, None]:
			parking[i][0] = [time, num]
			return
		if parking[i][0] == None:
			times.append((parking[i][1][0], i))
		elif parking[i][1] == None:
			times.append((parking[i][0][0], i))
	times.sort()
	for (t, ind) in times:
		if t >= time:
			if parking[ind][0] == None:
				parking[ind][0] = [time, num]
			else:
				parking[ind][1] = [time, num]
			return
	else:
		max_t = t
	for (t, ind) in times:
		if t == max_t:
			if parking[ind][0] == None:
				parking[ind][0] = [time, num]
			else:
				parking[ind][1] = [time, num]
			return
while True:
	(m, n) = map(int, input().split())
	if m == 0:
		break
	parking = [[None] * 2 for _ in range(m)]
	wait = deque()
	space = m * 2
	ans = []
	for t in range(120 * n):
		o = out(1, parking)
		if o:
			space += len(o)
			ans += o
		if t % 10 == 0 and t <= 10 * (n - 1):
			time = int(input())
			wait.append((t // 10 + 1, time))
		for i in range(min(space, len(wait))):
			(num, time) = wait.popleft()
			into(num, time, parking)
			space -= 1
	print(*ans)


from collections import deque

class Car:

	def __init__(self, rem, ind):
		self.ind = ind
		self.rem = rem

class Part:

	def __init__(self, i):
		self.ind = i
		self.top = None
		self.und = None
		self.sta = 0
		self.rem = -1

	def prog(self, time):
		if self.top != None:
			self.top.rem -= time
		if self.und != None:
			self.und.rem -= time
		if self.sta != 0:
			self.rem -= time

	def out(self):
		if self.sta == 2:
			if self.und.rem <= 0 and self.top.rem <= 0:
				outs = [self.und.ind, self.top.ind]
				self.und = None
				self.top = None
				self.sta = 0
				self.rem = -1
				return outs
			if self.und.rem <= 0:
				outs = [self.und.ind]
				self.und = None
				self.sta = 1
				self.rem = self.top.rem
				return outs
		if self.sta == 1:
			if self.top.rem <= 0:
				outs = [self.top.ind]
				self.top = None
				self.sta = 0
				self.rem = -1
				return outs
		return []

	def into(self, rem, ind):
		if self.sta == 0:
			self.top = Car(rem, ind)
			self.sta = 1
			self.rem = rem
		elif self.sta == 1:
			self.und = Car(rem, ind)
			self.sta = 2
			self.rem = rem

class Parking:

	def __init__(self, length):
		self.length = length
		self.max_space = length * 2
		self.space = length * 2
		self.body = [Part(i) for i in range(length)]

	def prog(self, time):
		for part in self.body:
			part.prog(time)

	def out(self):
		outs = []
		for part in self.body:
			if part.sta >= 1 and part.rem <= 0:
				outs.append(part.out())
		ret = []
		for out in outs:
			ret += out
		self.space += len(ret)
		return ret

	def into(self, rem, ind):
		self.space -= 1
		for part in self.body:
			if part.sta == 0:
				part.into(rem, ind)
				return
		rem_lst = []
		for part in self.body:
			if part.sta == 1:
				rem_lst.append((part.rem, part.ind))
		rem_lst.sort()
		for (r, i) in rem_lst:
			if r >= rem:
				self.body[i].into(rem, ind)
				return
		max_r = r
		for (r, i) in rem_lst:
			if r == max_r:
				self.body[i].into(rem, ind)
				return
while True:
	(m, n) = map(int, input().split())
	if m == 0:
		break
	parking = Parking(m)
	que = deque()
	ans = []
	for t in range(n * 120 - 1):
		parking.prog(1)
		ans += parking.out()
		if t <= (n - 1) * 10 and t % 10 == 0:
			r = int(input())
			que.append((r, t // 10 + 1))
		for i in range(min(parking.space, len(que))):
			(rem, ind) = que.popleft()
			parking.into(rem, ind)
	print(*ans)