#ifndef __NUMBERS_H__
#define __NUMBERS_H__

/* updated: 2019-10-10 */

#include <vector>
#include <cstdint>
#include <map>

uint64_t gcd(uint64_t a, uint64_t b);
uint64_t lcm(uint64_t a, uint64_t b);

uint64_t gcd(const std::vector<uint64_t>& values);
uint64_t lcm(const std::vector<uint64_t>& values);

int64_t extendedGcd(int64_t a, int64_t b, int64_t& x, int64_t& y);
std::pair<uint64_t, uint64_t> extendedGcdUnsigned(uint64_t a, uint64_t b);
uint64_t inverse(uint64_t a, uint64_t mod);


/* ax - by = c を解く関数を別に作ってもいいかも */

bool isPrime(uint64_t n);
std::vector<bool> primeTable(uint64_t max);
std::vector<uint64_t> primeList(uint64_t max);

std::map<uint64_t, int> factorize(uint64_t n);
std::vector<uint64_t> divisors(uint64_t n);

uint64_t totient(uint64_t n);
std::vector<uint64_t> totientTable(uint64_t max, const std::vector<uint64_t>& primes_ref = {});

std::map<uint64_t, int> moebius(uint64_t n);
std::vector<int> moebiusTable(uint64_t max, const std::vector<uint64_t>& primes_ref = {});

template <class T>
void transformDivisorZeta(std::vector<T>& arr, const std::vector<uint64_t>& primes_ref = {});
template <class T>
void transformInverseDivisorZeta(std::vector<T>& arr, const std::vector<uint64_t>& primes_ref = {});
template <class T>
void transformMultiplierZeta(std::vector<T>& arr, const std::vector<uint64_t>& primes_ref = {});
template <class T>
void transformInverseMultiplierZeta(std::vector<T>& arr, const std::vector<uint64_t>& primes_ref = {});
template <class T>
std::vector<T> convolveOnLcm(const std::vector<T>& a, const std::vector<T>& b);
template <class T>
std::vector<T> convolveOnGcd(const std::vector<T>& a, const std::vector<T>& b);

/* 約数ゼータ変換(破壊的) O(NloglogN); 第0要素は使用しない */
/* g[n] = sum [k divides n] f[k] */
template <class T>
void transformDivisorZeta(std::vector<T>& arr, const std::vector<uint64_t>& primes_ref) {
	const uint64_t n = arr.size() - 1;
	const std::vector<uint64_t>& primes = primes_ref.empty() ? primeList(n) : primes_ref;

	for (uint64_t p : primes) {
		for (uint64_t i = 1; i <= n / p; ++i) {
			arr[i * p] += arr[i];
		}
	}
}

/* 約数ゼータ変換の逆変換(破壊的) O(NloglogN) */
template <class T>
void transformInverseDivisorZeta(std::vector<T>& arr, const std::vector<uint64_t>& primes_ref) {
	const uint64_t n = arr.size() - 1;
	const std::vector<uint64_t>& primes = primes_ref.empty() ? primeList(n) : primes_ref;

	for (uint64_t p : primes) {
		for (uint64_t i = n / p; i >= 1; --i) {
			arr[i * p] -= arr[i];
		}
	}
}

/* 倍数ゼータ変換(破壊的) O(NloglogN) */
/* g[n] = sum [k is divided by n] f[k] */
template<class T>
void transformMultiplierZeta(std::vector<T>& arr, const std::vector<uint64_t>& primes_ref) {
	const uint64_t n = arr.size() - 1;
	const std::vector<uint64_t>& primes = primes_ref.empty() ? primeList(n) : primes_ref;

	for (uint64_t p : primes) {
		for (uint64_t i = n / p; i >= 1; --i) {
			arr[i] += arr[i * p];
		}
	}
}


/* 倍数ゼータ変換の逆変換(破壊的) O(NloglogN) */
template<class T>
void transformInverseMultiplierZeta(std::vector<T>& arr, const std::vector<uint64_t>& primes_ref) {
	const uint64_t n = arr.size() - 1;
	const std::vector<uint64_t>& primes = primes_ref.empty() ? primeList(n) : primes_ref;

	for (uint64_t p : primes) {
		for (uint64_t i = 1; i <= n / p; ++i) {
			arr[i] -= arr[i * p];
		}
	}
}

/* LCM畳み込み O(NloglogN); 第0要素は使用しない */
/* ret[n] = sum [lcm(i, j) == n] (a[i] * b[j]) */
template<class T>
std::vector<T> convolveOnLcm(const std::vector<T>& a, const std::vector<T>& b) {
	assert(a.size() == b.size());
	const int size = a.size();

	std::vector<uint64_t> primes = primeList(size - 1);
	std::vector<T> a_copied = a;
	std::vector<T> b_copied = b;
	transformDivisorZeta(a_copied, primes);
	transformDivisorZeta(b_copied, primes);

	std::vector<T> ret(size);
	for (int i = 1; i < size; ++i) {
		ret[i] = a_copied[i] * b_copied[i];
	}

	transformInverseDivisorZeta(ret, primes);
	return ret;
}

/* GCD畳み込み O(NloglogN); 第0要素は使用しない */
/* ret[n] = sum [gcd(i, j) == n] (a[i] * b[j]) */
template<class T>
std::vector<T> convolveOnGcd(const std::vector<T>& a, const std::vector<T>& b) {
	assert(a.size() == b.size());
	const int size = a.size();

	std::vector<uint64_t> primes = primeList(size - 1);
	std::vector<T> a_copied = a;
	std::vector<T> b_copied = b;
	transformMultiplierZeta(a_copied, primes);
	transformMultiplierZeta(b_copied, primes);

	std::vector<T> ret(size);
	for (int i = 1; i < size; ++i) {
		ret[i] = a_copied[i] * b_copied[i];
	}

	transformInverseMultiplierZeta(ret, primes);
	return ret;
}

#endif



#ifdef ONLY_MY_ENVIR
#include "Numbers.h"
#endif

#include <numeric>
#include <cassert>
#include <algorithm>

uint64_t gcd(uint64_t a, uint64_t b) {
	if (b == 0) return a;
	return gcd(b, a % b);
}

uint64_t lcm(uint64_t a, uint64_t b) {
	return a / gcd(a, b) * b;
}

uint64_t gcd(const std::vector<uint64_t>& values) {
	using FuncType = uint64_t(*)(uint64_t, uint64_t);
	return std::accumulate(values.begin(), values.end(), 0ULL, (FuncType)gcd);
}

uint64_t lcm(const std::vector<uint64_t>& values) {
	using FuncType = uint64_t(*)(uint64_t, uint64_t);
	return std::accumulate(values.begin(), values.end(), 1ULL, (FuncType)lcm);
}

/* ax + by = gcd(a, b) の整数解(絶対値最小?)を求める
 * a > 1 || b > 1 のとき abs(x) <= b / (2g) && abs(y) <= a / (2g) を満たす (g = gcd(a, b))
 * 返り値は gcd(a, b) */
int64_t extendedGcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
	if (b == 0) {
		x = 1;
		y = 0;
		return a;
	}
	uint64_t ret = extendedGcd(b, a % b, y, x);
	y -= (a / b) * x;
	return ret;
}

/* ax - by = gcd(a, b) の非負整数解を求める (x < b / g && y < a / g を満たす, g = gcd(a, b)) */
std::pair<uint64_t, uint64_t> extendedGcdUnsigned(uint64_t a, uint64_t b) {
	assert(a != 0 && b != 0);

	/* もともとの方程式の解 (x, y) が、
	 * 現在の (a, b) についての ap - bq = 1 の解 (p, q) の一次式で
	 * (x, y) = mat * (p, q) と書ける(ように mat を定める) */
	uint64_t mat[2][2] = {
		{ 1, 0 },
		{ 0, 1 }
	};

	while (true) {
		if (a > b) {
			if (a % b == 0) return std::make_pair(
				mat[0][0] + (a / b - 1) * mat[0][1],
				mat[1][0] + (a / b - 1) * mat[1][1]
			);
			mat[0][0] += (a / b) * mat[0][1];
			mat[1][0] += (a / b) * mat[1][1];
			a %= b;
		} else {
			if (b % a == 0) return std::make_pair(mat[0][0], mat[1][0]);
			mat[0][1] += (b / a) * mat[0][0];
			mat[1][1] += (b / a) * mat[1][0];
			b %= a;
		}
	}
}

/* mod における a の逆数(a と mod は互いに素) */
uint64_t inverse(uint64_t a, uint64_t mod) {
	assert(a != 0 && mod != 0);
	assert(gcd(a, mod) == 1);

	std::pair<uint64_t, uint64_t> res = extendedGcdUnsigned(a, mod);
	return res.first;
}

/* 素数判定 O(sqrt(N)) */
bool isPrime(uint64_t n) {
	if (n <= 1) return false;
	for (uint64_t i = 2; i * i <= n; ++i) {
		if (n % i == 0) return false;
	}
	return true;
}

/* エラトステネスの篩 O(NloglogN) */
std::vector<bool> primeTable(uint64_t max) {
	std::vector<bool> ret(max + 1, true);
	ret[0] = false;
	ret[1] = false;

	auto nextPrime = [max, &ret](uint64_t p) -> uint64_t {
		do {
			++p;
		} while (p <= max && !ret[p]);
		return p;
	};

	for (uint64_t p = 2; p * p <= max; p = nextPrime(p)) {
		for (uint64_t i = p * p; i <= max; i += p) {
			ret[i] = false;
		}
	}

	return ret;
}

/* 素数の昇順リストを生成 O(N * loglogN) */
std::vector<uint64_t> primeList(uint64_t max) {
	std::vector<bool> is_prime = primeTable(max);

	std::vector<uint64_t> list;
	for (uint64_t i = 2; i <= max; ++i) {
		if (is_prime[i]) {
			list.push_back(i);
		}
	}

	return list;
}

/* 素因数分解 O(sqrt(N)) */
std::map<uint64_t, int> factorize(uint64_t n) {
	std::map<uint64_t, int> ret;
	
	for (uint64_t i = 2; i * i <= n; ++i) {
		while (n % i == 0) {
			++ret[i];
			n /= i;
		}
	}

	if (n > 1) {
		++ret[n];
	}

	return ret;
}

/* 約数列挙 O(sqrt(N)) */
std::vector<uint64_t> divisors(uint64_t n) {
	std::map<uint64_t, int> factors = factorize(n);
	std::vector<uint64_t> ret;
	ret.push_back(1);

	for (const auto& pair : factors) {
		uint64_t prime = pair.first;
		int exp = pair.second;

		const uint64_t old_size = ret.size();
		for (uint64_t i = 0; i < old_size; ++i) {
			uint64_t divisor = ret[i];
			for (int k = 1; k <= exp; ++k) {
				divisor *= prime;
				ret.push_back(divisor);
			}
		}
	}
	std::sort(ret.begin(), ret.end());
	
	return ret;
}

/* オイラーのφ関数 O(sqrt(N)) */
uint64_t totient(uint64_t n) {
	assert(n > 0);

	std::map<uint64_t, int> factors = factorize(n);

	uint64_t ret = n;
	for (const auto& pair : factors) {
		uint64_t prime = pair.first;
		ret = ret / prime * (prime - 1);
	}
	return ret;
}

/* [1, n] に関してオイラーのφ関数の表を生成 O(NloglogN) */
std::vector<uint64_t> totientTable(uint64_t max, const std::vector<uint64_t>& primes_ref) {
	const std::vector<uint64_t>& primes = primes_ref.empty() ? primeList(max) : primes_ref;
	
	std::vector<uint64_t> ret(max + 1);
	std::iota(ret.begin(), ret.end(), uint64_t());
	for (uint64_t p : primes) {
		for (uint64_t i = p; i <= max; i += p) {
			ret[i] = ret[i] / p * (p - 1);
		}
	}

	return ret;
}

/* n の約数それぞれに関してメビウス関数の値を求める O(sqrt(N)) */
std::map<uint64_t, int> moebius(uint64_t n) {
	assert(n > 0);

	std::vector<uint64_t> primes;
	for (const auto& pair : factorize(n)) {
		primes.push_back(pair.first);
	}

	int prime_count = primes.size();
	std::map<uint64_t, int> ret;
	for (uint64_t s = 0; s < (uint64_t(1) << prime_count); ++s) {
		uint64_t product = 1;
		int value = 1;
		for (int i = 0; i < prime_count; ++i) {
			if (s & (uint64_t(1) << i)) {
				product *= primes[i];
				value = -value;
			}
		}
		ret[product] = value;
	}

	return ret;
}

/* [1, n] に関してメビウス関数の表を生成 O(NloglogN) */
std::vector<int> moebiusTable(uint64_t max, const std::vector<uint64_t>& primes_ref) {
	const std::vector<uint64_t>& primes = primes_ref.empty() ? primeList(max) : primes_ref;

	std::vector<int> ret(max + 1, 1);
	ret[0] = 0;

	/* p を約数に持つなら -1 倍 */
	for (uint64_t p : primes) {
		for (uint64_t i = p; i <= max; i += p) {
			ret[i] *= -1;
		}
	}

	/* p^2 を約数に持つなら 0 */
	for (uint64_t p : primes) {
		uint64_t p_sqr = p * p;		// オーバーフロー対策は必要ないと思うのでしない
		if (p_sqr > max) break;
		for (uint64_t i = p_sqr; i <= max; i += p_sqr) {
			ret[i] = 0;
		}
	}
	return ret;
}

#ifndef __VECTOR_UTIL_H__
#define __VECTOR_UTIL_H__

/* updated: 2020-03-14 */

#include <vector>
#include <iostream>
#include <algorithm>

template <class T>
std::vector<T> inputVector(int size, std::istream& ist = std::cin);
template <class T>
std::vector<std::vector<T>> inputVector2D(int height, int width, std::istream& ist = std::cin);
template <class T>
void outputVector(const std::vector<T>& vec, std::ostream& ost = std::cout);
template <class T>
std::vector<T> makeVector(int size, const T& value);
template <class T, class Func>
void apply(std::vector<T>& vec, Func func);

/* 標準入力から値を受け取り vector を生成 */
template <class T>
std::vector<T> inputVector(int size, std::istream& ist) {
	std::vector<T> ret(size);
	for (int i = 0; i < size; ++i) {
		ist >> ret[i];
	}
	return ret;
}

/* 標準入力から値を受け取り2次元 vector を生成 */
template <class T>
std::vector<std::vector<T>> inputVector2D(int height, int width, std::istream& ist) {
	std::vector<std::vector<T>> ret(height, std::vector<T>(width));
	for (int i = 0; i < height; ++i) {
		for (int j = 0; j < width; ++j) {
			ist >> ret[i][j];
		}
	}
	return ret;
}

template<class T>
void outputVector(const std::vector<T>& vec, std::ostream& ost) {
	int size = vec.size();
	for (int i = 0; i < size; ++i) {
		ost << vec[i];
		if (i == size - 1) {
			ost << std::endl;
		} else {
			ost << ' ';
		}
	}
}

/* vector 生成のヘルパー関数(主に多次元配列用) */
template <class T>
std::vector<T> makeVector(int size, const T& value) {
	return std::vector<T>(size, value);
}

/* vector の各要素に関数を適用する */
template <class T, class Func>
void apply(std::vector<T>& vec, Func func) {
	std::transform(vec.begin(), vec.end(), vec.begin(), func);
}

#endif

#define _CRT_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <utility>
#include <algorithm>
#include <functional>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <limits>
#include <numeric>
#include <valarray>
#include <fstream>
#include <array>
#include <random>
#include <unordered_set>
#include <unordered_map>

using namespace std;
using uint = uint32_t;
using LL = int64_t;
using ULL = uint64_t;
using PP = pair<LL, LL>;
template <typename T> using PriorityQ = priority_queue<T, vector<T>, greater<T> >;
#define REP(i, a, n) for(LL i = (a), i##_max_ = (n); i < i##_max_; ++i)
#define REM(i, a, n) for(LL i = (LL)(n) - 1, i##_min_ = (a); i >= i##_min_; --i)
#define FLOAT fixed << setprecision(16)
#define SPEEDUP { cin.tie(NULL); ios::sync_with_stdio(false); }
const int INF = 0x3FFFFFFF;
const LL INFLL = 0x3FFFFFFF3FFFFFFF;
const double INFD = 1.0e+308;
const double EPS = 1.0e-9;

void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T, class U> istream& operator>>(istream& ist, pair<T, U>& right) { return ist >> right.first >> right.second; }
template <class T, class U> ostream& operator<<(ostream& ost, const pair<T, U>& right) { return ost << right.first << ' ' << right.second; }
template <class T, class TCompatible, size_t N> void Fill(T(&dest)[N], const TCompatible& val) { fill(dest, dest + N, val); }
template <class T, class TCompatible, size_t M, size_t N> void Fill(T(&dest)[M][N], const TCompatible& val) { for (int i = 0; i < M; ++i) Fill(dest[i], val); }
template <class T> T Next() { T buf; cin >> buf; return buf; }
istream& Ignore(istream& ist) { string s; ist >> s; return ist; }
bool Inside(int i, int j, int h, int w) { return i >= 0 && i < h && j >= 0 && j < w; }

#ifdef ONLY_MY_ENVIR
#include "IntMod.h"
#include "Accumulator.h"
#include "Algebraic.h"
#include "BinaryMatrix.h"
#include "BinaryTree.h"
#include "Bipartite.h"
#include "BIT.h"
#include "Compressor.h"
#include "Decompositions.h"
#include "DynamicMod.h"
#include "Factorization.h"
#include "FFT.h"
#include "FlowSolver.h"
#include "Graph.h"
#include "GraphUtil.h"
#include "LazySegmentTree.h"
#include "LIS.h"
#include "Math.h"
#include "MathUtil.h"
#include "Matrix.h"
#include "MinCostFlowSolver.h"
#include "MinMax.h"
#include "Numbers.h"
#include "Optimize.h"
#include "Permutation.h"
#include "Polynomial.h"
#include "Position.h"
#include "Range.h"
#include "Rational.h"
#include "SegmentTree.h"
#include "SegmentTree2D.h"
#include "Sets.h"
#include "Shortest.h"
#include "SlidingWindow.h"
#include "SpanningTree.h"
#include "StringSearching.h"
#include "SuffixArray.h"
#include "Tree.h"
#include "UnionFind.h"
#include "VectorUtil.h"
#endif

#ifdef __GNUC__
typedef __int128 LLL;
istream& operator>>(istream& ist, __int128& val) { LL tmp; ist >> tmp; val = tmp; return ist; }
ostream& operator<<(ostream& ost, __int128 val) { LL tmp = val; ost << tmp; return ost; }
#endif

bool win(const vector<int>& v) {
	LL sum = accumulate(v.begin(), v.end(), 0ll);
	if (*min_element(v.begin(), v.end()) == 1) {
		return sum % 2 != v.size() % 2;
	}

	if (sum % 2 != v.size() % 2) return true;

	int odd = 0;
	for (int i : v) {
		if (i % 2 == 1) ++odd;
	}

	if (odd > 1) return false;
	vector<int> w(v);
	for (int& i : w) {
		i = i / 2 * 2;
	}

	int g = 0;
	for (int i : w) {
		g = gcd(g, i);
	}

	for (int& i : w) {
		i /= g;
	}
	return !win(w);
}

int main() {
	int N = Next<int>();
	auto A = inputVector<int>(N);
	puts(win(A) ? "First" : "Second");
	return 0;
}




Measured memory_bytes: 9600