description: You are given n integers a_1, a_2, …, a_n. Find the maximum value of max(a_l, a_{l + 1}, …, a_r) ⋅ min(a_l, a_{l + 1}, …, a_r) over all pairs (l, r) of integers for which 1 ≤ l < r ≤ n.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
  
  The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5).
  
  The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^6).
  
  It is guaranteed that the sum of n over all test cases doesn't exceed 3 ⋅ 10^5.
  
  Output
  
  For each test case, print a single integer — the maximum possible value of the product from the statement.
  
  Example
  
  Input
  
  
  4
  3
  2 4 3
  4
  3 2 3 1
  2
  69 69
  6
  719313 273225 402638 473783 804745 323328
  
  
  Output
  
  
  12
  6
  4761
  381274500335
  
  Note
  
  Let f(l, r) = max(a_l, a_{l + 1}, …, a_r) ⋅ min(a_l, a_{l + 1}, …, a_r).
  
  In the first test case, 
  
    * f(1, 2) = max(a_1, a_2) ⋅ min(a_1, a_2) = max(2, 4) ⋅ min(2, 4) = 4 ⋅ 2 = 8. 
    * f(1, 3) = max(a_1, a_2, a_3) ⋅ min(a_1, a_2, a_3) = max(2, 4, 3) ⋅ min(2, 4, 3) = 4 ⋅ 2 = 8. 
    * f(2, 3) = max(a_2, a_3) ⋅ min(a_2, a_3) = max(4, 3) ⋅ min(4, 3) = 4 ⋅ 3 = 12. 
  
  
  
  So the maximum is f(2, 3) = 12.
  
  In the second test case, the maximum is f(1, 2) = f(1, 3) = f(2, 3) = 6.
solution: # import sys
  # # from sortedcontainers import SortedList
  # input = sys.stdin.readline
  
   
  # from bisect import bisect_left, bisect_right, insort
  # from collections import Sequence, MutableSequence
  # from itertools import chain, repeat, starmap
  # from math import log
  # from operator import add, eq, ne, gt, ge, lt, le, iadd
  # from textwrap import dedent
   
  # ###############################################################################
  # # BEGIN Python 2/3 Shims
  # ###############################################################################
   
  # from functools import wraps
  # from sys import hexversion
   
  # if hexversion < 0x03000000:
  #     from itertools import imap as map  # pylint: disable=redefined-builtin
  #     from itertools import izip as zip  # pylint: disable=redefined-builtin
  #     try:
  #         from thread import get_ident
  #     except ImportError:
  #         from dummy_thread import get_ident
  # else:
  #     from functools import reduce
  #     try:
  #         from _thread import get_ident
  #     except ImportError:
  #         from _dummy_thread import get_ident
   
   
  # def recursive_repr(fillvalue='...'):
  #     "Decorator to make a repr function return fillvalue for a recursive call."
  #     # pylint: disable=missing-docstring
  #     # Copied from reprlib in Python 3
  #     # https://hg.python.org/cpython/file/3.6/Lib/reprlib.py
   
  #     def decorating_function(user_function):
  #         repr_running = set()
   
  #         @wraps(user_function)
  #         def wrapper(self):
  #             key = id(self), get_ident()
  #             if key in repr_running:
  #                 return fillvalue
  #             repr_running.add(key)
  #             try:
  #                 result = user_function(self)
  #             finally:
  #                 repr_running.discard(key)
  #             return result
   
  #         return wrapper
   
  #     return decorating_function
   
  # ###############################################################################
  # # END Python 2/3 Shims
  # ###############################################################################
   
   
  # class SortedList(MutableSequence):
  #     """Sorted list is a sorted mutable sequence.
  #     Sorted list values are maintained in sorted order.
  #     Sorted list values must be comparable. The total ordering of values must
  #     not change while they are stored in the sorted list.
  #     Methods for adding values:
  #     * :func:`SortedList.add`
  #     * :func:`SortedList.update`
  #     * :func:`SortedList.__add__`
  #     * :func:`SortedList.__iadd__`
  #     * :func:`SortedList.__mul__`
  #     * :func:`SortedList.__imul__`
  #     Methods for removing values:
  #     * :func:`SortedList.clear`
  #     * :func:`SortedList.discard`
  #     * :func:`SortedList.remove`
  #     * :func:`SortedList.pop`
  #     * :func:`SortedList.__delitem__`
  #     Methods for looking up values:
  #     * :func:`SortedList.bisect_left`
  #     * :func:`SortedList.bisect_right`
  #     * :func:`SortedList.count`
  #     * :func:`SortedList.index`
  #     * :func:`SortedList.__contains__`
  #     * :func:`SortedList.__getitem__`
  #     Methods for iterating values:
  #     * :func:`SortedList.irange`
  #     * :func:`SortedList.islice`
  #     * :func:`SortedList.__iter__`
  #     * :func:`SortedList.__reversed__`
  #     Methods for miscellany:
  #     * :func:`SortedList.copy`
  #     * :func:`SortedList.__len__`
  #     * :func:`SortedList.__repr__`
  #     * :func:`SortedList._check`
  #     * :func:`SortedList._reset`
  #     Sorted lists use lexicographical ordering semantics when compared to other
  #     sequences.
  #     Some methods of mutable sequences are not supported and will raise
  #     not-implemented error.
  #     """
  #     DEFAULT_LOAD_FACTOR = 1000
   
   
  #     def __init__(self, iterable=None, key=None):
  #         """Initialize sorted list instance.
  #         Optional `iterable` argument provides an initial iterable of values to
  #         initialize the sorted list.
  #         Runtime complexity: `O(n*log(n))`
  #         >>> sl = SortedList()
  #         >>> sl
  #         SortedList([])
  #         >>> sl = SortedList([3, 1, 2, 5, 4])
  #         >>> sl
  #         SortedList([1, 2, 3, 4, 5])
  #         :param iterable: initial values (optional)
  #         """
  #         assert key is None
  #         self._len = 0
  #         self._load = self.DEFAULT_LOAD_FACTOR
  #         self._lists = []
  #         self._maxes = []
  #         self._index = []
  #         self._offset = 0
   
  #         if iterable is not None:
  #             self._update(iterable)
   
   
  #     def __new__(cls, iterable=None, key=None):
  #         """Create new sorted list or sorted-key list instance.
  #         Optional `key`-function argument will return an instance of subtype
  #         :class:`SortedKeyList`.
  #         >>> sl = SortedList()
  #         >>> isinstance(sl, SortedList)
  #         True
  #         >>> sl = SortedList(key=lambda x: -x)
  #         >>> isinstance(sl, SortedList)
  #         True
  #         >>> isinstance(sl, SortedKeyList)
  #         True
  #         :param iterable: initial values (optional)
  #         :param key: function used to extract comparison key (optional)
  #         :return: sorted list or sorted-key list instance
  #         """
  #         # pylint: disable=unused-argument
  #         if key is None:
  #             return object.__new__(cls)
  #         else:
  #             if cls is SortedList:
  #                 return object.__new__(SortedKeyList)
  #             else:
  #                 raise TypeError('inherit SortedKeyList for key argument')
   
   
  #     @property
  #     def key(self):
  #         """Function used to extract comparison key from values.
  #         Sorted list compares values directly so the key function is none.
  #         """
  #         return None
   
   
  #     def _reset(self, load):
  #         """Reset sorted list load factor.
  #         The `load` specifies the load-factor of the list. The default load
  #         factor of 1000 works well for lists from tens to tens-of-millions of
  #         values. Good practice is to use a value that is the cube root of the
  #         list size. With billions of elements, the best load factor depends on
  #         your usage. It's best to leave the load factor at the default until you
  #         start benchmarking.
  #         See :doc:`implementation` and :doc:`performance-scale` for more
  #         information.
  #         Runtime complexity: `O(n)`
  #         :param int load: load-factor for sorted list sublists
  #         """
  #         values = reduce(iadd, self._lists, [])
  #         self._clear()
  #         self._load = load
  #         self._update(values)
   
   
  #     def clear(self):
  #         """Remove all values from sorted list.
  #         Runtime complexity: `O(n)`
  #         """
  #         self._len = 0
  #         del self._lists[:]
  #         del self._maxes[:]
  #         del self._index[:]
  #         self._offset = 0
   
  #     _clear = clear
   
   
  #     def add(self, value):
  #         """Add `value` to sorted list.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList()
  #         >>> sl.add(3)
  #         >>> sl.add(1)
  #         >>> sl.add(2)
  #         >>> sl
  #         SortedList([1, 2, 3])
  #         :param value: value to add to sorted list
  #         """
  #         _lists = self._lists
  #         _maxes = self._maxes
   
  #         if _maxes:
  #             pos = bisect_right(_maxes, value)
   
  #             if pos == len(_maxes):
  #                 pos -= 1
  #                 _lists[pos].append(value)
  #                 _maxes[pos] = value
  #             else:
  #                 insort(_lists[pos], value)
   
  #             self._expand(pos)
  #         else:
  #             _lists.append([value])
  #             _maxes.append(value)
   
  #         self._len += 1
   
   
  #     def _expand(self, pos):
  #         """Split sublists with length greater than double the load-factor.
  #         Updates the index when the sublist length is less than double the load
  #         level. This requires incrementing the nodes in a traversal from the
  #         leaf node to the root. For an example traversal see
  #         ``SortedList._loc``.
  #         """
  #         _load = self._load
  #         _lists = self._lists
  #         _index = self._index
   
  #         if len(_lists[pos]) > (_load << 1):
  #             _maxes = self._maxes
   
  #             _lists_pos = _lists[pos]
  #             half = _lists_pos[_load:]
  #             del _lists_pos[_load:]
  #             _maxes[pos] = _lists_pos[-1]
   
  #             _lists.insert(pos + 1, half)
  #             _maxes.insert(pos + 1, half[-1])
   
  #             del _index[:]
  #         else:
  #             if _index:
  #                 child = self._offset + pos
  #                 while child:
  #                     _index[child] += 1
  #                     child = (child - 1) >> 1
  #                 _index[0] += 1
   
   
  #     def update(self, iterable):
  #         """Update sorted list by adding all values from `iterable`.
  #         Runtime complexity: `O(k*log(n))` -- approximate.
  #         >>> sl = SortedList()
  #         >>> sl.update([3, 1, 2])
  #         >>> sl
  #         SortedList([1, 2, 3])
  #         :param iterable: iterable of values to add
  #         """
  #         _lists = self._lists
  #         _maxes = self._maxes
  #         values = sorted(iterable)
   
  #         if _maxes:
  #             if len(values) * 4 >= self._len:
  #                 values.extend(chain.from_iterable(_lists))
  #                 values.sort()
  #                 self._clear()
  #             else:
  #                 _add = self.add
  #                 for val in values:
  #                     _add(val)
  #                 return
   
  #         _load = self._load
  #         _lists.extend(values[pos:(pos + _load)]
  #                       for pos in range(0, len(values), _load))
  #         _maxes.extend(sublist[-1] for sublist in _lists)
  #         self._len = len(values)
  #         del self._index[:]
   
  #     _update = update
   
   
  #     def __contains__(self, value):
  #         """Return true if `value` is an element of the sorted list.
  #         ``sl.__contains__(value)`` <==> ``value in sl``
  #         Runtime complexity: `O(log(n))`
  #         >>> sl = SortedList([1, 2, 3, 4, 5])
  #         >>> 3 in sl
  #         True
  #         :param value: search for value in sorted list
  #         :return: true if `value` in sorted list
  #         """
  #         _maxes = self._maxes
   
  #         if not _maxes:
  #             return False
   
  #         pos = bisect_left(_maxes, value)
   
  #         if pos == len(_maxes):
  #             return False
   
  #         _lists = self._lists
  #         idx = bisect_left(_lists[pos], value)
   
  #         return _lists[pos][idx] == value
   
   
  #     def discard(self, value):
  #         """Remove `value` from sorted list if it is a member.
  #         If `value` is not a member, do nothing.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList([1, 2, 3, 4, 5])
  #         >>> sl.discard(5)
  #         >>> sl.discard(0)
  #         >>> sl == [1, 2, 3, 4]
  #         True
  #         :param value: `value` to discard from sorted list
  #         """
  #         _maxes = self._maxes
   
  #         if not _maxes:
  #             return
   
  #         pos = bisect_left(_maxes, value)
   
  #         if pos == len(_maxes):
  #             return
   
  #         _lists = self._lists
  #         idx = bisect_left(_lists[pos], value)
   
  #         if _lists[pos][idx] == value:
  #             self._delete(pos, idx)
   
   
  #     def remove(self, value):
  #         """Remove `value` from sorted list; `value` must be a member.
  #         If `value` is not a member, raise ValueError.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList([1, 2, 3, 4, 5])
  #         >>> sl.remove(5)
  #         >>> sl == [1, 2, 3, 4]
  #         True
  #         >>> sl.remove(0)
  #         Traceback (most recent call last):
  #           ...
  #         ValueError: 0 not in list
  #         :param value: `value` to remove from sorted list
  #         :raises ValueError: if `value` is not in sorted list
  #         """
  #         _maxes = self._maxes
   
  #         if not _maxes:
  #             raise ValueError('{0!r} not in list'.format(value))
   
  #         pos = bisect_left(_maxes, value)
   
  #         if pos == len(_maxes):
  #             raise ValueError('{0!r} not in list'.format(value))
   
  #         _lists = self._lists
  #         idx = bisect_left(_lists[pos], value)
   
  #         if _lists[pos][idx] == value:
  #             self._delete(pos, idx)
  #         else:
  #             raise ValueError('{0!r} not in list'.format(value))
   
   
  #     def _delete(self, pos, idx):
  #         """Delete value at the given `(pos, idx)`.
  #         Combines lists that are less than half the load level.
  #         Updates the index when the sublist length is more than half the load
  #         level. This requires decrementing the nodes in a traversal from the
  #         leaf node to the root. For an example traversal see
  #         ``SortedList._loc``.
  #         :param int pos: lists index
  #         :param int idx: sublist index
  #         """
  #         _lists = self._lists
  #         _maxes = self._maxes
  #         _index = self._index
   
  #         _lists_pos = _lists[pos]
   
  #         del _lists_pos[idx]
  #         self._len -= 1
   
  #         len_lists_pos = len(_lists_pos)
   
  #         if len_lists_pos > (self._load >> 1):
  #             _maxes[pos] = _lists_pos[-1]
   
  #             if _index:
  #                 child = self._offset + pos
  #                 while child > 0:
  #                     _index[child] -= 1
  #                     child = (child - 1) >> 1
  #                 _index[0] -= 1
  #         elif len(_lists) > 1:
  #             if not pos:
  #                 pos += 1
   
  #             prev = pos - 1
  #             _lists[prev].extend(_lists[pos])
  #             _maxes[prev] = _lists[prev][-1]
   
  #             del _lists[pos]
  #             del _maxes[pos]
  #             del _index[:]
   
  #             self._expand(prev)
  #         elif len_lists_pos:
  #             _maxes[pos] = _lists_pos[-1]
  #         else:
  #             del _lists[pos]
  #             del _maxes[pos]
  #             del _index[:]
   
   
  #     def _loc(self, pos, idx):
  #         """Convert an index pair (lists index, sublist index) into a single
  #         index number that corresponds to the position of the value in the
  #         sorted list.
  #         Many queries require the index be built. Details of the index are
  #         described in ``SortedList._build_index``.
  #         Indexing requires traversing the tree from a leaf node to the root. The
  #         parent of each node is easily computable at ``(pos - 1) // 2``.
  #         Left-child nodes are always at odd indices and right-child nodes are
  #         always at even indices.
  #         When traversing up from a right-child node, increment the total by the
  #         left-child node.
  #         The final index is the sum from traversal and the index in the sublist.
  #         For example, using the index from ``SortedList._build_index``::
  #             _index = 14 5 9 3 2 4 5
  #             _offset = 3
  #         Tree::
  #                  14
  #               5      9
  #             3   2  4   5
  #         Converting an index pair (2, 3) into a single index involves iterating
  #         like so:
  #         1. Starting at the leaf node: offset + alpha = 3 + 2 = 5. We identify
  #            the node as a left-child node. At such nodes, we simply traverse to
  #            the parent.
  #         2. At node 9, position 2, we recognize the node as a right-child node
  #            and accumulate the left-child in our total. Total is now 5 and we
  #            traverse to the parent at position 0.
  #         3. Iteration ends at the root.
  #         The index is then the sum of the total and sublist index: 5 + 3 = 8.
  #         :param int pos: lists index
  #         :param int idx: sublist index
  #         :return: index in sorted list
  #         """
  #         if not pos:
  #             return idx
   
  #         _index = self._index
   
  #         if not _index:
  #             self._build_index()
   
  #         total = 0
   
  #         # Increment pos to point in the index to len(self._lists[pos]).
   
  #         pos += self._offset
   
  #         # Iterate until reaching the root of the index tree at pos = 0.
   
  #         while pos:
   
  #             # Right-child nodes are at odd indices. At such indices
  #             # account the total below the left child node.
   
  #             if not pos & 1:
  #                 total += _index[pos - 1]
   
  #             # Advance pos to the parent node.
   
  #             pos = (pos - 1) >> 1
   
  #         return total + idx
   
   
  #     def _pos(self, idx):
  #         """Convert an index into an index pair (lists index, sublist index)
  #         that can be used to access the corresponding lists position.
  #         Many queries require the index be built. Details of the index are
  #         described in ``SortedList._build_index``.
  #         Indexing requires traversing the tree to a leaf node. Each node has two
  #         children which are easily computable. Given an index, pos, the
  #         left-child is at ``pos * 2 + 1`` and the right-child is at ``pos * 2 +
  #         2``.
  #         When the index is less than the left-child, traversal moves to the
  #         left sub-tree. Otherwise, the index is decremented by the left-child
  #         and traversal moves to the right sub-tree.
  #         At a child node, the indexing pair is computed from the relative
  #         position of the child node as compared with the offset and the remaining
  #         index.
  #         For example, using the index from ``SortedList._build_index``::
  #             _index = 14 5 9 3 2 4 5
  #             _offset = 3
  #         Tree::
  #                  14
  #               5      9
  #             3   2  4   5
  #         Indexing position 8 involves iterating like so:
  #         1. Starting at the root, position 0, 8 is compared with the left-child
  #            node (5) which it is greater than. When greater the index is
  #            decremented and the position is updated to the right child node.
  #         2. At node 9 with index 3, we again compare the index to the left-child
  #            node with value 4. Because the index is the less than the left-child
  #            node, we simply traverse to the left.
  #         3. At node 4 with index 3, we recognize that we are at a leaf node and
  #            stop iterating.
  #         4. To compute the sublist index, we subtract the offset from the index
  #            of the leaf node: 5 - 3 = 2. To compute the index in the sublist, we
  #            simply use the index remaining from iteration. In this case, 3.
  #         The final index pair from our example is (2, 3) which corresponds to
  #         index 8 in the sorted list.
  #         :param int idx: index in sorted list
  #         :return: (lists index, sublist index) pair
  #         """
  #         if idx < 0:
  #             last_len = len(self._lists[-1])
   
  #             if (-idx) <= last_len:
  #                 return len(self._lists) - 1, last_len + idx
   
  #             idx += self._len
   
  #             if idx < 0:
  #                 raise IndexError('list index out of range')
  #         elif idx >= self._len:
  #             raise IndexError('list index out of range')
   
  #         if idx < len(self._lists[0]):
  #             return 0, idx
   
  #         _index = self._index
   
  #         if not _index:
  #             self._build_index()
   
  #         pos = 0
  #         child = 1
  #         len_index = len(_index)
   
  #         while child < len_index:
  #             index_child = _index[child]
   
  #             if idx < index_child:
  #                 pos = child
  #             else:
  #                 idx -= index_child
  #                 pos = child + 1
   
  #             child = (pos << 1) + 1
   
  #         return (pos - self._offset, idx)
   
   
  #     def _build_index(self):
  #         """Build a positional index for indexing the sorted list.
  #         Indexes are represented as binary trees in a dense array notation
  #         similar to a binary heap.
  #         For example, given a lists representation storing integers::
  #             0: [1, 2, 3]
  #             1: [4, 5]
  #             2: [6, 7, 8, 9]
  #             3: [10, 11, 12, 13, 14]
  #         The first transformation maps the sub-lists by their length. The
  #         first row of the index is the length of the sub-lists::
  #             0: [3, 2, 4, 5]
  #         Each row after that is the sum of consecutive pairs of the previous
  #         row::
  #             1: [5, 9]
  #             2: [14]
  #         Finally, the index is built by concatenating these lists together::
  #             _index = [14, 5, 9, 3, 2, 4, 5]
  #         An offset storing the start of the first row is also stored::
  #             _offset = 3
  #         When built, the index can be used for efficient indexing into the list.
  #         See the comment and notes on ``SortedList._pos`` for details.
  #         """
  #         row0 = list(map(len, self._lists))
   
  #         if len(row0) == 1:
  #             self._index[:] = row0
  #             self._offset = 0
  #             return
   
  #         head = iter(row0)
  #         tail = iter(head)
  #         row1 = list(starmap(add, zip(head, tail)))
   
  #         if len(row0) & 1:
  #             row1.append(row0[-1])
   
  #         if len(row1) == 1:
  #             self._index[:] = row1 + row0
  #             self._offset = 1
  #             return
   
  #         size = 2 ** (int(log(len(row1) - 1, 2)) + 1)
  #         row1.extend(repeat(0, size - len(row1)))
  #         tree = [row0, row1]
   
  #         while len(tree[-1]) > 1:
  #             head = iter(tree[-1])
  #             tail = iter(head)
  #             row = list(starmap(add, zip(head, tail)))
  #             tree.append(row)
   
  #         reduce(iadd, reversed(tree), self._index)
  #         self._offset = size * 2 - 1
   
   
  #     def __delitem__(self, index):
  #         """Remove value at `index` from sorted list.
  #         ``sl.__delitem__(index)`` <==> ``del sl[index]``
  #         Supports slicing.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList('abcde')
  #         >>> del sl[2]
  #         >>> sl
  #         SortedList(['a', 'b', 'd', 'e'])
  #         >>> del sl[:2]
  #         >>> sl
  #         SortedList(['d', 'e'])
  #         :param index: integer or slice for indexing
  #         :raises IndexError: if index out of range
  #         """
  #         if isinstance(index, slice):
  #             start, stop, step = index.indices(self._len)
   
  #             if step == 1 and start < stop:
  #                 if start == 0 and stop == self._len:
  #                     return self._clear()
  #                 elif self._len <= 8 * (stop - start):
  #                     values = self._getitem(slice(None, start))
  #                     if stop < self._len:
  #                         values += self._getitem(slice(stop, None))
  #                     self._clear()
  #                     return self._update(values)
   
  #             indices = range(start, stop, step)
   
  #             # Delete items from greatest index to least so
  #             # that the indices remain valid throughout iteration.
   
  #             if step > 0:
  #                 indices = reversed(indices)
   
  #             _pos, _delete = self._pos, self._delete
   
  #             for index in indices:
  #                 pos, idx = _pos(index)
  #                 _delete(pos, idx)
  #         else:
  #             pos, idx = self._pos(index)
  #             self._delete(pos, idx)
   
   
  #     def __getitem__(self, index):
  #         """Lookup value at `index` in sorted list.
  #         ``sl.__getitem__(index)`` <==> ``sl[index]``
  #         Supports slicing.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList('abcde')
  #         >>> sl[1]
  #         'b'
  #         >>> sl[-1]
  #         'e'
  #         >>> sl[2:5]
  #         ['c', 'd', 'e']
  #         :param index: integer or slice for indexing
  #         :return: value or list of values
  #         :raises IndexError: if index out of range
  #         """
  #         _lists = self._lists
   
  #         if isinstance(index, slice):
  #             start, stop, step = index.indices(self._len)
   
  #             if step == 1 and start < stop:
  #                 if start == 0 and stop == self._len:
  #                     return reduce(iadd, self._lists, [])
   
  #                 start_pos, start_idx = self._pos(start)
   
  #                 if stop == self._len:
  #                     stop_pos = len(_lists) - 1
  #                     stop_idx = len(_lists[stop_pos])
  #                 else:
  #                     stop_pos, stop_idx = self._pos(stop)
   
  #                 if start_pos == stop_pos:
  #                     return _lists[start_pos][start_idx:stop_idx]
   
  #                 prefix = _lists[start_pos][start_idx:]
  #                 middle = _lists[(start_pos + 1):stop_pos]
  #                 result = reduce(iadd, middle, prefix)
  #                 result += _lists[stop_pos][:stop_idx]
   
  #                 return result
   
  #             if step == -1 and start > stop:
  #                 result = self._getitem(slice(stop + 1, start + 1))
  #                 result.reverse()
  #                 return result
   
  #             # Return a list because a negative step could
  #             # reverse the order of the items and this could
  #             # be the desired behavior.
   
  #             indices = range(start, stop, step)
  #             return list(self._getitem(index) for index in indices)
  #         else:
  #             if self._len:
  #                 if index == 0:
  #                     return _lists[0][0]
  #                 elif index == -1:
  #                     return _lists[-1][-1]
  #             else:
  #                 raise IndexError('list index out of range')
   
  #             if 0 <= index < len(_lists[0]):
  #                 return _lists[0][index]
   
  #             len_last = len(_lists[-1])
   
  #             if -len_last < index < 0:
  #                 return _lists[-1][len_last + index]
   
  #             pos, idx = self._pos(index)
  #             return _lists[pos][idx]
   
  #     _getitem = __getitem__
   
   
  #     def __setitem__(self, index, value):
  #         """Raise not-implemented error.
  #         ``sl.__setitem__(index, value)`` <==> ``sl[index] = value``
  #         :raises NotImplementedError: use ``del sl[index]`` and
  #             ``sl.add(value)`` instead
  #         """
  #         message = 'use ``del sl[index]`` and ``sl.add(value)`` instead'
  #         raise NotImplementedError(message)
   
   
  #     def __iter__(self):
  #         """Return an iterator over the sorted list.
  #         ``sl.__iter__()`` <==> ``iter(sl)``
  #         Iterating the sorted list while adding or deleting values may raise a
  #         :exc:`RuntimeError` or fail to iterate over all values.
  #         """
  #         return chain.from_iterable(self._lists)
   
   
  #     def __reversed__(self):
  #         """Return a reverse iterator over the sorted list.
  #         ``sl.__reversed__()`` <==> ``reversed(sl)``
  #         Iterating the sorted list while adding or deleting values may raise a
  #         :exc:`RuntimeError` or fail to iterate over all values.
  #         """
  #         return chain.from_iterable(map(reversed, reversed(self._lists)))
   
   
  #     def reverse(self):
  #         """Raise not-implemented error.
  #         Sorted list maintains values in ascending sort order. Values may not be
  #         reversed in-place.
  #         Use ``reversed(sl)`` for an iterator over values in descending sort
  #         order.
  #         Implemented to override `MutableSequence.reverse` which provides an
  #         erroneous default implementation.
  #         :raises NotImplementedError: use ``reversed(sl)`` instead
  #         """
  #         raise NotImplementedError('use ``reversed(sl)`` instead')
   
   
  #     def islice(self, start=None, stop=None, reverse=False):
  #         """Return an iterator that slices sorted list from `start` to `stop`.
  #         The `start` and `stop` index are treated inclusive and exclusive,
  #         respectively.
  #         Both `start` and `stop` default to `None` which is automatically
  #         inclusive of the beginning and end of the sorted list.
  #         When `reverse` is `True` the values are yielded from the iterator in
  #         reverse order; `reverse` defaults to `False`.
  #         >>> sl = SortedList('abcdefghij')
  #         >>> it = sl.islice(2, 6)
  #         >>> list(it)
  #         ['c', 'd', 'e', 'f']
  #         :param int start: start index (inclusive)
  #         :param int stop: stop index (exclusive)
  #         :param bool reverse: yield values in reverse order
  #         :return: iterator
  #         """
  #         _len = self._len
   
  #         if not _len:
  #             return iter(())
   
  #         start, stop, _ = slice(start, stop).indices(self._len)
   
  #         if start >= stop:
  #             return iter(())
   
  #         _pos = self._pos
   
  #         min_pos, min_idx = _pos(start)
   
  #         if stop == _len:
  #             max_pos = len(self._lists) - 1
  #             max_idx = len(self._lists[-1])
  #         else:
  #             max_pos, max_idx = _pos(stop)
   
  #         return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
   
   
  #     def _islice(self, min_pos, min_idx, max_pos, max_idx, reverse):
  #         """Return an iterator that slices sorted list using two index pairs.
  #         The index pairs are (min_pos, min_idx) and (max_pos, max_idx), the
  #         first inclusive and the latter exclusive. See `_pos` for details on how
  #         an index is converted to an index pair.
  #         When `reverse` is `True`, values are yielded from the iterator in
  #         reverse order.
  #         """
  #         _lists = self._lists
   
  #         if min_pos > max_pos:
  #             return iter(())
   
  #         if min_pos == max_pos:
  #             if reverse:
  #                 indices = reversed(range(min_idx, max_idx))
  #                 return map(_lists[min_pos].__getitem__, indices)
   
  #             indices = range(min_idx, max_idx)
  #             return map(_lists[min_pos].__getitem__, indices)
   
  #         next_pos = min_pos + 1
   
  #         if next_pos == max_pos:
  #             if reverse:
  #                 min_indices = range(min_idx, len(_lists[min_pos]))
  #                 max_indices = range(max_idx)
  #                 return chain(
  #                     map(_lists[max_pos].__getitem__, reversed(max_indices)),
  #                     map(_lists[min_pos].__getitem__, reversed(min_indices)),
  #                 )
   
  #             min_indices = range(min_idx, len(_lists[min_pos]))
  #             max_indices = range(max_idx)
  #             return chain(
  #                 map(_lists[min_pos].__getitem__, min_indices),
  #                 map(_lists[max_pos].__getitem__, max_indices),
  #             )
   
  #         if reverse:
  #             min_indices = range(min_idx, len(_lists[min_pos]))
  #             sublist_indices = range(next_pos, max_pos)
  #             sublists = map(_lists.__getitem__, reversed(sublist_indices))
  #             max_indices = range(max_idx)
  #             return chain(
  #                 map(_lists[max_pos].__getitem__, reversed(max_indices)),
  #                 chain.from_iterable(map(reversed, sublists)),
  #                 map(_lists[min_pos].__getitem__, reversed(min_indices)),
  #             )
   
  #         min_indices = range(min_idx, len(_lists[min_pos]))
  #         sublist_indices = range(next_pos, max_pos)
  #         sublists = map(_lists.__getitem__, sublist_indices)
  #         max_indices = range(max_idx)
  #         return chain(
  #             map(_lists[min_pos].__getitem__, min_indices),
  #             chain.from_iterable(sublists),
  #             map(_lists[max_pos].__getitem__, max_indices),
  #         )
   
   
  #     def irange(self, minimum=None, maximum=None, inclusive=(True, True),
  #                reverse=False):
  #         """Create an iterator of values between `minimum` and `maximum`.
  #         Both `minimum` and `maximum` default to `None` which is automatically
  #         inclusive of the beginning and end of the sorted list.
  #         The argument `inclusive` is a pair of booleans that indicates whether
  #         the minimum and maximum ought to be included in the range,
  #         respectively. The default is ``(True, True)`` such that the range is
  #         inclusive of both minimum and maximum.
  #         When `reverse` is `True` the values are yielded from the iterator in
  #         reverse order; `reverse` defaults to `False`.
  #         >>> sl = SortedList('abcdefghij')
  #         >>> it = sl.irange('c', 'f')
  #         >>> list(it)
  #         ['c', 'd', 'e', 'f']
  #         :param minimum: minimum value to start iterating
  #         :param maximum: maximum value to stop iterating
  #         :param inclusive: pair of booleans
  #         :param bool reverse: yield values in reverse order
  #         :return: iterator
  #         """
  #         _maxes = self._maxes
   
  #         if not _maxes:
  #             return iter(())
   
  #         _lists = self._lists
   
  #         # Calculate the minimum (pos, idx) pair. By default this location
  #         # will be inclusive in our calculation.
   
  #         if minimum is None:
  #             min_pos = 0
  #             min_idx = 0
  #         else:
  #             if inclusive[0]:
  #                 min_pos = bisect_left(_maxes, minimum)
   
  #                 if min_pos == len(_maxes):
  #                     return iter(())
   
  #                 min_idx = bisect_left(_lists[min_pos], minimum)
  #             else:
  #                 min_pos = bisect_right(_maxes, minimum)
   
  #                 if min_pos == len(_maxes):
  #                     return iter(())
   
  #                 min_idx = bisect_right(_lists[min_pos], minimum)
   
  #         # Calculate the maximum (pos, idx) pair. By default this location
  #         # will be exclusive in our calculation.
   
  #         if maximum is None:
  #             max_pos = len(_maxes) - 1
  #             max_idx = len(_lists[max_pos])
  #         else:
  #             if inclusive[1]:
  #                 max_pos = bisect_right(_maxes, maximum)
   
  #                 if max_pos == len(_maxes):
  #                     max_pos -= 1
  #                     max_idx = len(_lists[max_pos])
  #                 else:
  #                     max_idx = bisect_right(_lists[max_pos], maximum)
  #             else:
  #                 max_pos = bisect_left(_maxes, maximum)
   
  #                 if max_pos == len(_maxes):
  #                     max_pos -= 1
  #                     max_idx = len(_lists[max_pos])
  #                 else:
  #                     max_idx = bisect_left(_lists[max_pos], maximum)
   
  #         return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
   
   
  #     def __len__(self):
  #         """Return the size of the sorted list.
  #         ``sl.__len__()`` <==> ``len(sl)``
  #         :return: size of sorted list
  #         """
  #         return self._len
   
   
  #     def bisect_left(self, value):
  #         """Return an index to insert `value` in the sorted list.
  #         If the `value` is already present, the insertion point will be before
  #         (to the left of) any existing values.
  #         Similar to the `bisect` module in the standard library.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList([10, 11, 12, 13, 14])
  #         >>> sl.bisect_left(12)
  #         2
  #         :param value: insertion index of value in sorted list
  #         :return: index
  #         """
  #         _maxes = self._maxes
   
  #         if not _maxes:
  #             return 0
   
  #         pos = bisect_left(_maxes, value)
   
  #         if pos == len(_maxes):
  #             return self._len
   
  #         idx = bisect_left(self._lists[pos], value)
  #         return self._loc(pos, idx)
   
   
  #     def bisect_right(self, value):
  #         """Return an index to insert `value` in the sorted list.
  #         Similar to `bisect_left`, but if `value` is already present, the
  #         insertion point with be after (to the right of) any existing values.
  #         Similar to the `bisect` module in the standard library.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList([10, 11, 12, 13, 14])
  #         >>> sl.bisect_right(12)
  #         3
  #         :param value: insertion index of value in sorted list
  #         :return: index
  #         """
  #         _maxes = self._maxes
   
  #         if not _maxes:
  #             return 0
   
  #         pos = bisect_right(_maxes, value)
   
  #         if pos == len(_maxes):
  #             return self._len
   
  #         idx = bisect_right(self._lists[pos], value)
  #         return self._loc(pos, idx)
   
  #     bisect = bisect_right
  #     _bisect_right = bisect_right
   
   
  #     def count(self, value):
  #         """Return number of occurrences of `value` in the sorted list.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
  #         >>> sl.count(3)
  #         3
  #         :param value: value to count in sorted list
  #         :return: count
  #         """
  #         _maxes = self._maxes
   
  #         if not _maxes:
  #             return 0
   
  #         pos_left = bisect_left(_maxes, value)
   
  #         if pos_left == len(_maxes):
  #             return 0
   
  #         _lists = self._lists
  #         idx_left = bisect_left(_lists[pos_left], value)
  #         pos_right = bisect_right(_maxes, value)
   
  #         if pos_right == len(_maxes):
  #             return self._len - self._loc(pos_left, idx_left)
   
  #         idx_right = bisect_right(_lists[pos_right], value)
   
  #         if pos_left == pos_right:
  #             return idx_right - idx_left
   
  #         right = self._loc(pos_right, idx_right)
  #         left = self._loc(pos_left, idx_left)
  #         return right - left
   
   
  #     def copy(self):
  #         """Return a shallow copy of the sorted list.
  #         Runtime complexity: `O(n)`
  #         :return: new sorted list
  #         """
  #         return self.__class__(self)
   
  #     __copy__ = copy
   
   
  #     def append(self, value):
  #         """Raise not-implemented error.
  #         Implemented to override `MutableSequence.append` which provides an
  #         erroneous default implementation.
  #         :raises NotImplementedError: use ``sl.add(value)`` instead
  #         """
  #         raise NotImplementedError('use ``sl.add(value)`` instead')
   
   
  #     def extend(self, values):
  #         """Raise not-implemented error.
  #         Implemented to override `MutableSequence.extend` which provides an
  #         erroneous default implementation.
  #         :raises NotImplementedError: use ``sl.update(values)`` instead
  #         """
  #         raise NotImplementedError('use ``sl.update(values)`` instead')
   
   
  #     def insert(self, index, value):
  #         """Raise not-implemented error.
  #         :raises NotImplementedError: use ``sl.add(value)`` instead
  #         """
  #         raise NotImplementedError('use ``sl.add(value)`` instead')
   
   
  #     def pop(self, index=-1):
  #         """Remove and return value at `index` in sorted list.
  #         Raise :exc:`IndexError` if the sorted list is empty or index is out of
  #         range.
  #         Negative indices are supported.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList('abcde')
  #         >>> sl.pop()
  #         'e'
  #         >>> sl.pop(2)
  #         'c'
  #         >>> sl
  #         SortedList(['a', 'b', 'd'])
  #         :param int index: index of value (default -1)
  #         :return: value
  #         :raises IndexError: if index is out of range
  #         """
  #         if not self._len:
  #             raise IndexError('pop index out of range')
   
  #         _lists = self._lists
   
  #         if index == 0:
  #             val = _lists[0][0]
  #             self._delete(0, 0)
  #             return val
   
  #         if index == -1:
  #             pos = len(_lists) - 1
  #             loc = len(_lists[pos]) - 1
  #             val = _lists[pos][loc]
  #             self._delete(pos, loc)
  #             return val
   
  #         if 0 <= index < len(_lists[0]):
  #             val = _lists[0][index]
  #             self._delete(0, index)
  #             return val
   
  #         len_last = len(_lists[-1])
   
  #         if -len_last < index < 0:
  #             pos = len(_lists) - 1
  #             loc = len_last + index
  #             val = _lists[pos][loc]
  #             self._delete(pos, loc)
  #             return val
   
  #         pos, idx = self._pos(index)
  #         val = _lists[pos][idx]
  #         self._delete(pos, idx)
  #         return val
   
   
  #     def index(self, value, start=None, stop=None):
  #         """Return first index of value in sorted list.
  #         Raise ValueError if `value` is not present.
  #         Index must be between `start` and `stop` for the `value` to be
  #         considered present. The default value, None, for `start` and `stop`
  #         indicate the beginning and end of the sorted list.
  #         Negative indices are supported.
  #         Runtime complexity: `O(log(n))` -- approximate.
  #         >>> sl = SortedList('abcde')
  #         >>> sl.index('d')
  #         3
  #         >>> sl.index('z')
  #         Traceback (most recent call last):
  #           ...
  #         ValueError: 'z' is not in list
  #         :param value: value in sorted list
  #         :param int start: start index (default None, start of sorted list)
  #         :param int stop: stop index (default None, end of sorted list)
  #         :return: index of value
  #         :raises ValueError: if value is not present
  #         """
  #         _len = self._len
   
  #         if not _len:
  #             raise ValueError('{0!r} is not in list'.format(value))
   
  #         if start is None:
  #             start = 0
  #         if start < 0:
  #             start += _len
  #         if start < 0:
  #             start = 0
   
  #         if stop is None:
  #             stop = _len
  #         if stop < 0:
  #             stop += _len
  #         if stop > _len:
  #             stop = _len
   
  #         if stop <= start:
  #             raise ValueError('{0!r} is not in list'.format(value))
   
  #         _maxes = self._maxes
  #         pos_left = bisect_left(_maxes, value)
   
  #         if pos_left == len(_maxes):
  #             raise ValueError('{0!r} is not in list'.format(value))
   
  #         _lists = self._lists
  #         idx_left = bisect_left(_lists[pos_left], value)
   
  #         if _lists[pos_left][idx_left] != value:
  #             raise ValueError('{0!r} is not in list'.format(value))
   
  #         stop -= 1
  #         left = self._loc(pos_left, idx_left)
   
  #         if start <= left:
  #             if left <= stop:
  #                 return left
  #         else:
  #             right = self._bisect_right(value) - 1
   
  #             if start <= right:
  #                 return start
   
  #         raise ValueError('{0!r} is not in list'.format(value))
   
   
  #     def __add__(self, other):
  #         """Return new sorted list containing all values in both sequences.
  #         ``sl.__add__(other)`` <==> ``sl + other``
  #         Values in `other` do not need to be in sorted order.
  #         Runtime complexity: `O(n*log(n))`
  #         >>> sl1 = SortedList('bat')
  #         >>> sl2 = SortedList('cat')
  #         >>> sl1 + sl2
  #         SortedList(['a', 'a', 'b', 'c', 't', 't'])
  #         :param other: other iterable
  #         :return: new sorted list
  #         """
  #         values = reduce(iadd, self._lists, [])
  #         values.extend(other)
  #         return self.__class__(values)
   
  #     __radd__ = __add__
   
   
  #     def __iadd__(self, other):
  #         """Update sorted list with values from `other`.
  #         ``sl.__iadd__(other)`` <==> ``sl += other``
  #         Values in `other` do not need to be in sorted order.
  #         Runtime complexity: `O(k*log(n))` -- approximate.
  #         >>> sl = SortedList('bat')
  #         >>> sl += 'cat'
  #         >>> sl
  #         SortedList(['a', 'a', 'b', 'c', 't', 't'])
  #         :param other: other iterable
  #         :return: existing sorted list
  #         """
  #         self._update(other)
  #         return self
   
   
  #     def __mul__(self, num):
  #         """Return new sorted list with `num` shallow copies of values.
  #         ``sl.__mul__(num)`` <==> ``sl * num``
  #         Runtime complexity: `O(n*log(n))`
  #         >>> sl = SortedList('abc')
  #         >>> sl * 3
  #         SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'])
  #         :param int num: count of shallow copies
  #         :return: new sorted list
  #         """
  #         values = reduce(iadd, self._lists, []) * num
  #         return self.__class__(values)
   
  #     __rmul__ = __mul__
   
   
  #     def __imul__(self, num):
  #         """Update the sorted list with `num` shallow copies of values.
  #         ``sl.__imul__(num)`` <==> ``sl *= num``
  #         Runtime complexity: `O(n*log(n))`
  #         >>> sl = SortedList('abc')
  #         >>> sl *= 3
  #         >>> sl
  #         SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'])
  #         :param int num: count of shallow copies
  #         :return: existing sorted list
  #         """
  #         values = reduce(iadd, self._lists, []) * num
  #         self._clear()
  #         self._update(values)
  #         return self
   
   
  #     def __make_cmp(seq_op, symbol, doc):
  #         "Make comparator method."
  #         def comparer(self, other):
  #             "Compare method for sorted list and sequence."
  #             if not isinstance(other, Sequence):
  #                 return NotImplemented
   
  #             self_len = self._len
  #             len_other = len(other)
   
  #             if self_len != len_other:
  #                 if seq_op is eq:
  #                     return False
  #                 if seq_op is ne:
  #                     return True
   
  #             for alpha, beta in zip(self, other):
  #                 if alpha != beta:
  #                     return seq_op(alpha, beta)
   
  #             return seq_op(self_len, len_other)
   
  #         seq_op_name = seq_op.__name__
  #         comparer.__name__ = '__{0}__'.format(seq_op_name)
  #         doc_str = """Return true if and only if sorted list is {0} `other`.
  #         ``sl.__{1}__(other)`` <==> ``sl {2} other``
  #         Comparisons use lexicographical order as with sequences.
  #         Runtime complexity: `O(n)`
  #         :param other: `other` sequence
  #         :return: true if sorted list is {0} `other`
  #         """
  #         comparer.__doc__ = dedent(doc_str.format(doc, seq_op_name, symbol))
  #         return comparer
   
   
  #     __eq__ = __make_cmp(eq, '==', 'equal to')
  #     __ne__ = __make_cmp(ne, '!=', 'not equal to')
  #     __lt__ = __make_cmp(lt, '<', 'less than')
  #     __gt__ = __make_cmp(gt, '>', 'greater than')
  #     __le__ = __make_cmp(le, '<=', 'less than or equal to')
  #     __ge__ = __make_cmp(ge, '>=', 'greater than or equal to')
  #     __make_cmp = staticmethod(__make_cmp)
   
   
  #     @recursive_repr()
  #     def __repr__(self):
  #         """Return string representation of sorted list.
  #         ``sl.__repr__()`` <==> ``repr(sl)``
  #         :return: string representation
  #         """
  #         return '{0}({1!r})'.format(type(self).__name__, list(self))
   
   
  #     def _check(self):
  #         """Check invariants of sorted list.
  #         Runtime complexity: `O(n)`
  #         """
  #         try:
  #             assert self._load >= 4
  #             assert len(self._maxes) == len(self._lists)
  #             assert self._len == sum(len(sublist) for sublist in self._lists)
   
  #             # Check all sublists are sorted.
   
  #             for sublist in self._lists:
  #                 for pos in range(1, len(sublist)):
  #                     assert sublist[pos - 1] <= sublist[pos]
   
  #             # Check beginning/end of sublists are sorted.
   
  #             for pos in range(1, len(self._lists)):
  #                 assert self._lists[pos - 1][-1] <= self._lists[pos][0]
   
  #             # Check _maxes index is the last value of each sublist.
   
  #             for pos in range(len(self._maxes)):
  #                 assert self._maxes[pos] == self._lists[pos][-1]
   
  #             # Check sublist lengths are less than double load-factor.
   
  #             double = self._load << 1
  #             assert all(len(sublist) <= double for sublist in self._lists)
   
  #             # Check sublist lengths are greater than half load-factor for all
  #             # but the last sublist.
   
  #             half = self._load >> 1
  #             for pos in range(0, len(self._lists) - 1):
  #                 assert len(self._lists[pos]) >= half
   
  #             if self._index:
  #                 assert self._len == self._index[0]
  #                 assert len(self._index) == self._offset + len(self._lists)
   
  #                 # Check index leaf nodes equal length of sublists.
   
  #                 for pos in range(len(self._lists)):
  #                     leaf = self._index[self._offset + pos]
  #                     assert leaf == len(self._lists[pos])
   
  #                 # Check index branch nodes are the sum of their children.
   
  #                 for pos in range(self._offset):
  #                     child = (pos << 1) + 1
  #                     if child >= len(self._index):
  #                         assert self._index[pos] == 0
  #                     elif child + 1 == len(self._index):
  #                         assert self._index[pos] == self._index[child]
  #                     else:
  #                         child_sum = self._index[child] + self._index[child + 1]
  #                         assert child_sum == self._index[pos]
  #         except:
  #             import sys
  #             import traceback
  #             traceback.print_exc(file=sys.stdout)
  #             print('len', self._len)
  #             print('load', self._load)
  #             print('offset', self._offset)
  #             print('len_index', len(self._index))
  #             print('index', self._index)
  #             print('len_maxes', len(self._maxes))
  #             print('maxes', self._maxes)
  #             print('len_lists', len(self._lists))
  #             print('lists', self._lists)
  #             raise
  # ############ ---- Input Functions ---- ############
  # def inp():
  #     return(int(input()))
  # def inlt():
  #     return(list(map(int,input().split())))
  # def insr():
  #     s = input()
  #     return(list(s[:len(s) - 1]))
  # def invr():
  #     return(map(int,input().split()))
  
  # for t in range(inp()):
  #     n=inp()
  #     arr=inlt()
  #     s=SortedList(arr)
  #     i=0
  #     j=n-1
  #     mi=s[0]
  #     ma=s[-1]
  #     ans=mi*ma
  #     while i!=j:
  #         if arr[i]<arr[j]:
  #             s.remove(arr[i])
  #             i+=1
  #         else:
  #             s.remove(arr[j])
  #             j-=1
  #         mi=s[0]
  #         ma=s[-1]
  #         # print(mi,ma,i,j)
  #         if mi*ma>ans and i!=j:
  #             ans=mi*ma
  #     print(ans)
          
          
          
          
  import sys
  # from sortedcontainers import SortedList
  input = sys.stdin.readline
  
   
  
  ############ ---- Input Functions ---- ############
  def inp():
      return(int(input()))
  def inlt():
      return(list(map(int,input().split())))
  def insr():
      s = input()
      return(list(s[:len(s) - 1]))
  def invr():
      return(map(int,input().split()))
  
  for t in range(inp()):
      n=inp()
      arr=inlt()
      s=[]
      for i in range(1,n):
          su=arr[i]*arr[i-1]
          s.append(su)
      ans=max(s)
  
      print(ans)
          
          
          
          
          
          
          
          
      
      
          
          
          
          
      
      
  