Problem: You are given an array a consisting of n integers. You can perform the following operations with it: 

  1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell; 
  2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning). 



The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.

Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.

Input

The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.

The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.

Output

Print n - 1 lines. The k-th line should contain one of the two possible operations.

The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.

The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.

If there are multiple possible sequences of operations leading to the maximum number — print any of them.

Examples

Input

5
5 -2 0 1 -3


Output

2 3
1 1 2
1 2 4
1 4 5


Input

5
5 2 0 4 0


Output

1 3 5
2 5
1 1 2
1 2 4


Input

2
2 -1


Output

2 2


Input

4
0 -10 0 0


Output

1 1 2
1 2 3
1 3 4


Input

4
0 0 0 0


Output

1 1 2
1 2 3
1 3 4

Note

Let X be the removed number in the array. Let's take a look at all the examples:

The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.

The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed: 
    
    
      
    1 5 3  
    1 4 2  
    1 2 1  
    2 3  
    

Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].

The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].

The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].

The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].

Solution (in PYTHON3):

Solution:
from enum import Enum

class OperationType(Enum):
	Multiply = 1
	Remove = 2

class RemoveOperation:
	def __init__(self, index):
		self.type = OperationType.Remove
		self.index = index

	def __repr__(self):
		return "RemoveOperation({})".format(self.index)

class MultiplyOperation:
	def __init__(self, index_a, index_b):
		self.type = OperationType.Multiply
		self.index_a = index_a
		self.index_b = index_b

	def __repr__(self):
		return "MultiplyOperation({}, {})".format(self.index_a, self.index_b)

def multiply_remaining(removed, n):
	"""
	Removed should be list of 1-based indices
	"""
	operations = []
	keep_indices = set(range(1, n + 1)) - set(removed)
	previous = None
	for index in sorted(keep_indices):
		if previous is not None:
			operations.append(MultiplyOperation(previous, index))
		previous = index
	return operations

def multiply_everything(n):
	operations = []
	for i in range(1, n):
		operations.append(MultiplyOperation(i, i + 1))
	return operations

def remove_indices_and_multiply_remaining(removed, n):
	"""
	Removed should be a collection of 1-based indices
	"""
	operations = []
	keep_indices = set(range(1, n + 1)) - set(removed)
	previous = None
	for index in sorted(keep_indices):
		if previous is not None:
			operations.append(MultiplyOperation(previous, index))
		previous = index
	return operations

def find_zero_indices(xs):
	"""
	Returns sorted list of 1-based indices
	"""
	zero_indices = []
	for index, x, in enumerate(xs):
		if x == 0:
			zero_indices.append(index + 1)
	return zero_indices

def remove_indices_and_multiply_remaining(indices_to_remove, n):
	"""
	indices_to_remove should be a sorted list of 1-based indices
	"""
	# multiply together indices to remove and then actually remove last one
	operations = []
	previous = None
	for index in indices_to_remove:
		if previous is not None:
			operations.append(MultiplyOperation(previous, index))
		previous = index
	
	if len(indices_to_remove) < n:
		operations.append(RemoveOperation(previous))
		operations += multiply_remaining(indices_to_remove, n)
	return operations

def find_index_of_largest_negative(xs):
	# or index of smallest absolute value negative
	# returns 1 based index
	maximum = float('-inf')
	maximum_index = None
	for index, x in enumerate(xs):
		if x < 0 and x > maximum:
			maximum = x
			maximum_index = index
	return maximum_index + 1

def solve(xs):
	"""
	Returns list of |xs| - 1 operations
	"""
	n = len(xs)
	# Count negatives and zeros
	negatives = 0
	zeros = 0
	for x in xs:
		if x == 0:
			zeros += 1
		if x < 0:
			negatives += 1
	
	if zeros == 0 and negatives == 0:
		# all positive so just multiply everything to maximize
		return multiply_everything(n)
	elif zeros == n:
		# can only be left with 0, multiply everything...
		return multiply_everything(n)
	elif zeros == 0 and negatives > 0:
		if negatives % 2 == 0:
			# multiply everything for largest positive number
			return multiply_everything(n)
		else:
			# get rid of smallest absolute value negative to be left with even number of negatives
			# then multiply everything for largest positive number
			return remove_indices_and_multiply_remaining([find_index_of_largest_negative(xs)], n)
	elif negatives == 0 and zeros > 0:
		return remove_indices_and_multiply_remaining(find_zero_indices(xs), n)
	else:#if zeros > 0 and negatives > 0
		if negatives % 2 == 0:
			# get rid of zeros and
			# multiply everything for largest positive number
			return remove_indices_and_multiply_remaining(find_zero_indices(xs), n)
		else:
			# get rid of zeros as well as smallest negative number
			# then multiply everything for largest positive number
			indices_to_remove = sorted([find_index_of_largest_negative(xs)] + find_zero_indices(xs))
			return remove_indices_and_multiply_remaining(indices_to_remove, n)

def verify(xs, maximum):
	solution = solve(xs)
	#print("solve(", xs, ") returned ", solution)

	assert len(solution) == len(xs) - 1

	num_removes = 0
	removed = [False] * len(xs)
	for operation in solution:
		if operation.type is OperationType.Remove:
			assert not removed[operation.index - 1]
			num_removes += 1
			removed[operation.index - 1] = True
		elif operation.type is OperationType.Multiply:
			assert not removed[operation.index_a - 1]
			assert not removed[operation.index_b - 1]
			removed[operation.index_a - 1] = True
			xs[operation.index_b - 1] *= xs[operation.index_a - 1]

	assert num_removes <= 1

	num_remaining = 0
	remaining_index = -1
	for index, value in enumerate(xs):
		if not removed[index]:
			num_remaining += 1
			remaining_index = index
		
	assert num_remaining == 1
	assert maximum == xs[remaining_index]

n = int(input())
xs = list(map(int, input().split()))[:n]
for operation in solve(xs):
	if operation.type is OperationType.Multiply:
		print(1, operation.index_a, operation.index_b)
	else:
		print(2, operation.index)

# verify([-1, -1, -1, -1, -1, -1], 1)
# verify([-1, -1, -1, -1, -1], 1)
# verify([-1, -1, -100, -1, -1], 100)
# verify([-100, -1, -1, -1, -1], 100)
# verify([0, 0], 0)
# verify([0, 0, 0], 0)
# verify([1, 2, 3], 6)
# verify([0, 2, 3], 6)
# verify([2, 0, 3], 6)
# verify([2, 1, 0, 3], 6)
# verify([2, 2, 0, 3], 12)
# verify([2, 2, 0, 0, 3], 12)
# verify([2, 2, 0, 0, 0, 3], 12)
# verify([0, 2, 2, 0, 0, 0, 3], 12)
# verify([2, 2, 0, 0, 0, 3], 12)
# verify([0, 2, 0, 2, 0, 0, 0, 3, 0], 12)
# verify([-1, 2, 3], 6)
# verify([2, -1, 3], 6)
# verify([2, 3, -100], 6)
# verify([2, 0, 3, -1, -100], 600)
# verify([2, 0, -1, -100, 3, -2, -2], 2400)
# verify([2, 0, -1, -100, 3, -2, -2, 0], 2400)
# verify([2, 0, -1, -100, 3, -2, -2, 0, 2], 4800)
# verify([0, -1, 5], 5)
# verify([0, -1, 0, 5], 5)
# verify([0, -1, 0, -100, 5], 500)
# verify([0, -2, 0, -100, -5, 5], 2500)
# verify([0, -10, 0, 0], 0)
# verify([0, -10, -10, 0], 100)