output_description: If Takahashi will win, print `First`. If Aoki will win, print `Second`.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N
      A_1 A_2 … A_N
attempt: #
  # 　　  ⋀_⋀
  # 　　  (･ω･)
  # .／ Ｕ ∽ Ｕ＼
  #  │＊　合　＊│
  #  │＊　格　＊│
  #  │＊　祈　＊│
  #  │＊　願　＊│
  #  │＊　　　＊│
  #      ￣
  #
  import sys
  
  sys.setrecursionlimit(10**6)
  input = sys.stdin.readline
  from math import floor, sqrt, factorial, hypot, log  # log2ないｙｐ
  from heapq import heappop, heappush, heappushpop
  from collections import Counter, defaultdict, deque
  from itertools import (
      accumulate,
      permutations,
      combinations,
      product,
      combinations_with_replacement,
  )
  from bisect import bisect_left, bisect_right
  from copy import deepcopy
  from fractions import gcd
  from random import randint
  
  
  def ceil(a, b):
      return (a + b - 1) // b
  
  
  inf = float("inf")
  mod = 10**9 + 7
  
  
  def pprint(*A):
      for a in A:
          print(*a, sep="\n")
  
  
  def INT_(n):
      return int(n) - 1
  
  
  def MI():
      return map(int, input().split())
  
  
  def MF():
      return map(float, input().split())
  
  
  def MI_():
      return map(INT_, input().split())
  
  
  def LI():
      return list(MI())
  
  
  def LI_():
      return [int(x) - 1 for x in input().split()]
  
  
  def LF():
      return list(MF())
  
  
  def LIN(n: int):
      return [I() for _ in range(n)]
  
  
  def LLIN(n: int):
      return [LI() for _ in range(n)]
  
  
  def LLIN_(n: int):
      return [LI_() for _ in range(n)]
  
  
  def LLI():
      return [list(map(int, l.split())) for l in input()]
  
  
  def I():
      return int(input())
  
  
  def F():
      return float(input())
  
  
  def ST():
      return input().replace("\n", "")
  
  
  def gcd_list(A):
      res = A[0]
      for a in A:
          res = gcd(a, res)
      return res
  
  
  def check(N, A):
      if 1 in A:
          if (sum(A) - N) & 1:
              return 0  # 先手
          else:
              return 1  # 後手
      odd_cnt, even_cnt = 0, 0
      for a in A:
          if a & 1:
              odd_cnt += 1
          else:
              even_cnt += 1
      if even_cnt & 1:
          return 0
      else:
          if odd_cnt >= 2:
              return 1
          else:  ##奇数のを選ぶしかないのでその後どうなるかを調べる
              odd_idx = [i for i in range(N) if A[i] & 1][0]
              A[odd_idx] -= 1
              G = gcd_list(A)
              return check(N, [a // G for a in A])
  
  
  def main():
      N = I()
      A = LI()
      print(["First", "Second"][check(N, A)])
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  There are N integers written on a blackboard. The i-th integer is A_i, and the
  greatest common divisor of these integers is 1.
  
  Takahashi and Aoki will play a game using these integers. In this game,
  starting from Takahashi the two player alternately perform the following
  operation:
  
    * Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
    * Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
  
  The player who is left with only 1s on the blackboard and thus cannot perform
  the operation, loses the game. Assuming that both players play optimally,
  determine the winner of the game.
samples: [{"input": "3\n    3 6 7", "output": "First\n    \n\nTakahashi, the first player, can win as follows:\n\n  * Takahashi subtracts 1 from 7. Then, the integers become: (1,2,2).\n  * Aoki subtracts 1 from 2. Then, the integers become: (1,1,2).\n  * Takahashi subtracts 1 from 2. Then, the integers become: (1,1,1).\n\n* * *"}, {"input": "4\n    1 2 4 8", "output": "First\n    \n\n* * *"}, {"input": "5\n    7 8 8 8 8", "output": "Second"}]