/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author RiaD
 */

#include <iostream>
#include <fstream>

#include <iostream>
#include <cassert>


#include <iterator>


#include <string>
#include <stdexcept>

#ifndef SPCPPL_ASSERT
	#ifdef SPCPPL_DEBUG
		#define SPCPPL_ASSERT(condition) \
		if(!(condition)) { \
			throw std::runtime_error(std::string() + #condition + " in line " + std::to_string(__LINE__) + " in " + __PRETTY_FUNCTION__); \
		}
	#else
		#define SPCPPL_ASSERT(condition)
	#endif
#endif


/**
* Support decrementing and multi-passing, but not declared bidirectional(or even forward) because
* it's reference type is not a reference.
*
* It doesn't return reference because
* 1. Anyway it'll not satisfy requirement [forward.iterators]/6
*   If a and b are both dereferenceable, then a == b if and only if *a and
*   b are bound to the same object.
* 2. It'll not work with reverse_iterator that returns operator * of temporary which is temporary for this iterator
*
* Note, reverse_iterator is not guaranteed to work  now too since it works only with bidirectional iterators,
* but it's seems to work at least on my implementation.
*
* It's not really useful anywhere except iterating anyway.
*/
template <typename T>
class IntegerIterator: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
public:
	explicit IntegerIterator(T value): value(value) {

	}

	IntegerIterator& operator++() {
		++value;
		return *this;
	}

	IntegerIterator operator++(int) {
		IntegerIterator copy = *this;
		++value;
		return copy;
	}

	IntegerIterator& operator--() {
		--value;
		return *this;
	}

	IntegerIterator operator--(int) {
		IntegerIterator copy = *this;
		--value;
		return copy;
	}

	T operator*() const {
		return value;
	}

	bool operator==(IntegerIterator rhs) const {
		return value == rhs.value;
	}

	bool operator!=(IntegerIterator rhs) const {
		return !(*this == rhs);
	}

private:
	T value;
};

template <typename T>
class IntegerRange {
public:
	IntegerRange(T begin, T end): begin_(begin), end_(end) {
		SPCPPL_ASSERT(begin <= end);
	}

	IntegerIterator<T> begin() const {
		return IntegerIterator<T>(begin_);
	}

	IntegerIterator<T> end() const {
		return IntegerIterator<T>(end_);
	}

private:
	T begin_;
	T end_;
};

template <typename T>
class ReversedIntegerRange {
	typedef std::reverse_iterator<IntegerIterator<T>> IteratorType;
public:
	ReversedIntegerRange(T begin, T end): begin_(begin), end_(end) {
		SPCPPL_ASSERT(begin >= end);
	}

	IteratorType begin() const {
		return IteratorType(IntegerIterator<T>(begin_));
	}

	IteratorType end() const {
		return IteratorType(IntegerIterator<T>(end_));
	}

private:
	T begin_;
	T end_;
};

template <typename T>
IntegerRange<T> range(T to) {
	return IntegerRange<T>(0, to);
}

template <typename T>
IntegerRange<T> range(T from, T to) {
	return IntegerRange<T>(from, to);
}

template <typename T>
IntegerRange<T> inclusiveRange(T to) {
	return IntegerRange<T>(0, to + 1);
}

template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
	return IntegerRange<T>(from, to + 1);
}

template <typename T>
ReversedIntegerRange<T> downrange(T from) {
	return ReversedIntegerRange<T>(from, 0);
}

template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
	return ReversedIntegerRange<T>(from, to);
}

template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
	return ReversedIntegerRange<T>(from + 1, 0);
}

template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
	return ReversedIntegerRange<T>(from + 1, to);
}

#include <vector>
#include <map>


template <typename T>
T gcd(T a, T b) {
	while (b) {
		T tmp = a % b;
		a = b;
		b = tmp;
	}
	return a;
}

using namespace std;

class TaskD {
	int testNumber = 0;
public:
	void solve(std::istream& in, std::ostream& out) {
		//out << "Case #" << ++testNumber << ": ";
		//cerr << "Running test: " << testNumber << endl;
		//

		//
		//for (int i: range(1, 15)) {
		//	for (int j: range(1, 15)) {
		//		for (int k: range(1, 15)) {
		//			if (gcd(k, gcd(i, j)) == 1) {
		//				bool r1 = first_win_fast({i, j, k});
		//				bool r2 = first_win_slow({i, j, k});
		//				if (r1 != r2) {
		//					cerr << i << ' ' << j << ' ' << k<< endl;
		//					cerr << r1 << ' ' << r2 << endl;
		//					return;
		//				}
		//			}
		//		}
		//	}
		//}
		//return;

		int n;
		in >> n;
		vector<int> v(n);
		for (int i: range(n)) {
			in >> v[i];
		}
		if (n == 1) {
			assert(v[0] == 1);
		}



		if (first_win_fast(v)) {
			out << "First\n";
		} else {
			out << "Second\n";
		}

	}

	bool first_win_fast(vector<int> v) {
		int64_t sum = 0;
		for (int x: v) {
			sum += x - 1;
		}
		if (sum % 2) {
			return true;
		}
		int count_odd = 0;
		for (int i: v) {
			if (i == 1) {
				return false;
			}
			if (i % 2) {
				++count_odd;
			}
		}
		if (count_odd == 1) {
			vector<int> vv = v;
			for (int& i: vv) {
				if (i % 2) {
					--i;
				}
			}
			int g = 0;
			for (int x: vv) {
				g = gcd(x,  g);
			}
			for (int& x: vv) {
				x /= g;
			}
			return !first_win_fast(vv);
		}
		return false;
	}

	std::map<vector<int>, bool> ans;

	bool first_win_slow(vector<int> v) {
		if(ans.count(v)) {
			return ans[v];
		}

		int g = 0;
		for (int x: v) {
			g = gcd(x, g);
		}

		for (int& x: v) {
			x /= g;
		}

		bool& res = ans[v];

		for (int i: range(v.size())) {
			if (v[i] == 1) {
				continue;
			}
			auto vv = v;
			--vv[i];
			if (!first_win_slow(vv)) {
				return (res = true);
			}
		}
		return (res = false);
	}

};


int main() {
	std::ios_base::sync_with_stdio(false);
	TaskD solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	in.tie(nullptr);
	out << std::fixed;
	out.precision(20);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 19072