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: # ---------------------------iye ha aam zindegi---------------------------------------------
  from itertools import permutations
  import math
  import random
  import heapq,bisect
  import sys
  from collections import deque, defaultdict
  from fractions import Fraction
  import sys
  from collections import defaultdict
  mod = 10 ** 9 + 7
  mod1 = 998244353
  
  # ------------------------------warmup----------------------------
  import os
  import sys
  from io import BytesIO, IOBase
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
              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")
  
  
  # -------------------game starts now----------------------------------------------------import math
  class TreeNode:
      def __init__(self, k, v):
          self.key = k
          self.value = v
          self.left = None
          self.right = None
          self.parent = None
          self.height = 1
          self.num_left = 1
          self.num_total = 1
  
  
  class AvlTree:
  
      def __init__(self):
          self._tree = None
  
      def add(self, k, v):
          if not self._tree:
              self._tree = TreeNode(k, v)
              return
          node = self._add(k, v)
          if node:
              self._rebalance(node)
  
      def _add(self, k, v):
          node = self._tree
          while node:
              if k < node.key:
                  if node.left:
                      node = node.left
                  else:
                      node.left = TreeNode(k, v)
                      node.left.parent = node
                      return node.left
              elif node.key < k:
                  if node.right:
                      node = node.right
                  else:
                      node.right = TreeNode(k, v)
                      node.right.parent = node
                      return node.right
              else:
                  node.value = v
                  return
  
      @staticmethod
      def get_height(x):
          return x.height if x else 0
  
      @staticmethod
      def get_num_total(x):
          return x.num_total if x else 0
  
      def _rebalance(self, node):
  
          n = node
          while n:
              lh = self.get_height(n.left)
              rh = self.get_height(n.right)
              n.height = max(lh, rh) + 1
              balance_factor = lh - rh
              n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
              n.num_left = 1 + self.get_num_total(n.left)
  
              if balance_factor > 1:
                  if self.get_height(n.left.left) < self.get_height(n.left.right):
                      self._rotate_left(n.left)
                  self._rotate_right(n)
              elif balance_factor < -1:
                  if self.get_height(n.right.right) < self.get_height(n.right.left):
                      self._rotate_right(n.right)
                  self._rotate_left(n)
              else:
                  n = n.parent
  
      def _remove_one(self, node):
          """
          Side effect!!! Changes node. Node should have exactly one child
          """
          replacement = node.left or node.right
          if node.parent:
              if AvlTree._is_left(node):
                  node.parent.left = replacement
              else:
                  node.parent.right = replacement
              replacement.parent = node.parent
              node.parent = None
          else:
              self._tree = replacement
              replacement.parent = None
          node.left = None
          node.right = None
          node.parent = None
          self._rebalance(replacement)
  
      def _remove_leaf(self, node):
          if node.parent:
              if AvlTree._is_left(node):
                  node.parent.left = None
              else:
                  node.parent.right = None
              self._rebalance(node.parent)
          else:
              self._tree = None
          node.parent = None
          node.left = None
          node.right = None
  
      def remove(self, k):
          node = self._get_node(k)
          if not node:
              return
          if AvlTree._is_leaf(node):
              self._remove_leaf(node)
              return
          if node.left and node.right:
              nxt = AvlTree._get_next(node)
              node.key = nxt.key
              node.value = nxt.value
              if self._is_leaf(nxt):
                  self._remove_leaf(nxt)
              else:
                  self._remove_one(nxt)
              self._rebalance(node)
          else:
              self._remove_one(node)
  
      def get(self, k):
          node = self._get_node(k)
          return node.value if node else -1
  
      def _get_node(self, k):
          if not self._tree:
              return None
          node = self._tree
          while node:
              if k < node.key:
                  node = node.left
              elif node.key < k:
                  node = node.right
              else:
                  return node
          return None
  
      def get_at(self, pos):
          x = pos + 1
          node = self._tree
          while node:
              if x < node.num_left:
                  node = node.left
              elif node.num_left < x:
                  x -= node.num_left
                  node = node.right
              else:
                  return (node.key, node.value)
          raise IndexError("Out of ranges")
  
      @staticmethod
      def _is_left(node):
          return node.parent.left and node.parent.left == node
  
      @staticmethod
      def _is_leaf(node):
          return node.left is None and node.right is None
  
      def _rotate_right(self, node):
          if not node.parent:
              self._tree = node.left
              node.left.parent = None
          elif AvlTree._is_left(node):
              node.parent.left = node.left
              node.left.parent = node.parent
          else:
              node.parent.right = node.left
              node.left.parent = node.parent
          bk = node.left.right
          node.left.right = node
          node.parent = node.left
          node.left = bk
          if bk:
              bk.parent = node
          node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
          node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
          node.num_left = 1 + self.get_num_total(node.left)
  
      def _rotate_left(self, node):
          if not node.parent:
              self._tree = node.right
              node.right.parent = None
          elif AvlTree._is_left(node):
              node.parent.left = node.right
              node.right.parent = node.parent
          else:
              node.parent.right = node.right
              node.right.parent = node.parent
          bk = node.right.left
          node.right.left = node
          node.parent = node.right
          node.right = bk
          if bk:
              bk.parent = node
          node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
          node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
          node.num_left = 1 + self.get_num_total(node.left)
  
      @staticmethod
      def _get_next(node):
          if not node.right:
              return node.parent
          n = node.right
          while n.left:
              n = n.left
          return n
  
  
  # -----------------------------------------------binary seacrh tree---------------------------------------
  class SegmentTree1:
      def __init__(self, data, default=2*10**9, func=lambda a, b: min(a,b)):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # -------------------game starts now----------------------------------------------------import math
  class SegmentTree:
      def __init__(self, data, default=0, func=lambda a, b: a+b):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # -------------------------------iye ha chutiya zindegi-------------------------------------
  class Factorial:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorials = [1, 1]
          self.invModulos = [0, 1]
          self.invFactorial_ = [1, 1]
  
      def calc(self, n):
          if n <= -1:
              print("Invalid argument to calculate n!")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          if n < len(self.factorials):
              return self.factorials[n]
          nextArr = [0] * (n + 1 - len(self.factorials))
          initialI = len(self.factorials)
          prev = self.factorials[-1]
          m = self.MOD
          for i in range(initialI, n + 1):
              prev = nextArr[i - initialI] = prev * i % m
          self.factorials += nextArr
          return self.factorials[n]
  
      def inv(self, n):
          if n <= -1:
              print("Invalid argument to calculate n^(-1)")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          p = self.MOD
          pi = n % p
          if pi < len(self.invModulos):
              return self.invModulos[pi]
          nextArr = [0] * (n + 1 - len(self.invModulos))
          initialI = len(self.invModulos)
          for i in range(initialI, min(p, n + 1)):
              next = -self.invModulos[p % i] * (p // i) % p
              self.invModulos.append(next)
          return self.invModulos[pi]
  
      def invFactorial(self, n):
          if n <= -1:
              print("Invalid argument to calculate (n^(-1))!")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          if n < len(self.invFactorial_):
              return self.invFactorial_[n]
          self.inv(n)  # To make sure already calculated n^-1
          nextArr = [0] * (n + 1 - len(self.invFactorial_))
          initialI = len(self.invFactorial_)
          prev = self.invFactorial_[-1]
          p = self.MOD
          for i in range(initialI, n + 1):
              prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
          self.invFactorial_ += nextArr
          return self.invFactorial_[n]
  
  
  class Combination:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorial = Factorial(MOD)
  
      def ncr(self, n, k):
          if k < 0 or n < k:
              return 0
          k = min(k, n - k)
          f = self.factorial
          return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
  
  
  # --------------------------------------iye ha combinations ka zindegi---------------------------------
  def powm(a, n, m):
      if a == 1 or n == 0:
          return 1
      if n % 2 == 0:
          s = powm(a, n // 2, m)
          return s * s % m
      else:
          return a * powm(a, n - 1, m) % m
  
  
  # --------------------------------------iye ha power ka zindegi---------------------------------
  def sort_list(list1, list2):
      zipped_pairs = zip(list2, list1)
  
      z = [x for _, x in sorted(zipped_pairs)]
  
      return z
  
  
  # --------------------------------------------------product----------------------------------------
  def product(l):
      por = 1
      for i in range(len(l)):
          por *= l[i]
      return por
  
  
  # --------------------------------------------------binary----------------------------------------
  def binarySearchCount(arr, n, key):
      left = 0
      right = n - 1
  
      count = 0
  
      while (left <= right):
          mid = int((right + left) / 2)
  
          # Check if middle element is
          # less than or equal to key
          if (arr[mid] < key):
              count = mid + 1
              left = mid + 1
  
          # If key is smaller, ignore right half
          else:
              right = mid - 1
  
      return count
  
  
  # --------------------------------------------------binary----------------------------------------
  def countdig(n):
      c = 0
      while (n > 0):
          n //= 10
          c += 1
      return c
  def binary(x, length):
      y = bin(x)[2:]
      return y if len(y) >= length else "0" * (length - len(y)) + y
  
  def countGreater(arr, n, k):
      l = 0
      r = n - 1
  
      # Stores the index of the left most element
      # from the array which is greater than k
      leftGreater = n
  
      # Finds number of elements greater than k
      while (l <= r):
          m = int(l + (r - l) / 2)
          if (arr[m] >= k):
              leftGreater = m
              r = m - 1
  
          # If mid element is less than
          # or equal to k update l
          else:
              l = m + 1
  
      # Return the count of elements
      # greater than k
      return (n - leftGreater)
  
  class TrieNode:
      def __init__(self):
          self.children = [None] * 26
          self.isEndOfWord = False
  class Trie:
      def __init__(self):
          self.root = self.getNode()
      def getNode(self):
          return TrieNode()
      def _charToIndex(self, ch):
          return ord(ch) - ord('a')
      def insert(self, key):
          pCrawl = self.root
          length = len(key)
          for level in range(length):
              index = self._charToIndex(key[level])
              if not pCrawl.children[index]:
                  pCrawl.children[index] = self.getNode()
              pCrawl = pCrawl.children[index]
          pCrawl.isEndOfWord = True
      def search(self, key):
          pCrawl = self.root
          length = len(key)
          for level in range(length):
              index = self._charToIndex(key[level])
              if not pCrawl.children[index]:
                  return False
              pCrawl = pCrawl.children[index]
          return pCrawl != None and pCrawl.isEndOfWord
  #-----------------------------------------trie---------------------------------
  class Node:
      def __init__(self, data):
          self.data = data
          self.count=0
          self.left = None  # left node for 0
          self.right = None  # right node for 1
  class BinaryTrie:
      def __init__(self):
          self.root = Node(0)
      def insert(self, pre_xor):
          self.temp = self.root
          for i in range(31, -1, -1):
              val = pre_xor & (1 << i)
              if val:
                  if not self.temp.right:
                      self.temp.right = Node(0)
                  self.temp = self.temp.right
                  self.temp.count+=1
              if not val:
                  if not self.temp.left:
                      self.temp.left = Node(0)
                  self.temp = self.temp.left
                  self.temp.count += 1
          self.temp.data = pre_xor
      def query(self, xor):
          self.temp = self.root
          for i in range(31, -1, -1):
              val = xor & (1 << i)
              if not val:
                  if self.temp.left and self.temp.left.count>0:
                      self.temp = self.temp.left
                  elif self.temp.right:
                      self.temp = self.temp.right
              else:
                  if self.temp.right and self.temp.right.count>0:
                      self.temp = self.temp.right
                  elif self.temp.left:
                      self.temp = self.temp.left
              self.temp.count-=1
          return xor ^ self.temp.data
  # --------------------------------------------------binary-----------------------------------
  for ik in range(int(input())):
      n=int(input())
      l=list(map(int,input().split()))
      ma=max(l)
      ans=l[0]*l[1]
      for i in range(n):
          if i>0:
              ans=max(ans,l[i]*l[i-1])
          if i<n-1:
              ans=max(ans,l[i]*l[i+1])
      print(ans)