#include <bits/stdc++.h>
using namespace std;
struct BigNum {
  vector<long long> value;
  void set(long long x) {
    value = *(new vector<long long>);
    value.push_back(x);
  }
  void duplicate(BigNum other) { value = other.value; }
  void add(BigNum other) {
    vector<long long> o = other.value;
    if (o.size() > value.size()) {
      vector<long long> t = value;
      value = o;
      o = t;
    }
    for (int i = 0; i < o.size(); i += 1) {
      value[i] += o[i];
      if (i < value.size() - 1 && value[i] >= (long long)1e9) {
        value[i + 1] += value[i] / (long long)1e9;
        value[i] = value[i] % (long long)1e9;
      }
    }
    if (value.back() >= (long long)1e9) {
      value.push_back(value.back() / (long long)1e9);
      value[value.size() - 2] = value[value.size() - 2] % (long long)1e9;
    }
  }
  void mul(long long mul) {
    for (int i = 0; i < value.size(); i += 1) {
      value[i] *= mul;
    }
    for (int i = 0; i < value.size() - 1; i += 1) {
      if (value[i] >= (long long)1e9) {
        value[i + 1] += value[i] / (long long)1e9;
        value[i] = value[i] % (long long)1e9;
      }
    }
    if (value.back() >= (long long)1e9) {
      value.push_back(value.back() / (long long)1e9);
      value[value.size() - 2] = value[value.size() - 2] % (long long)1e9;
    }
  }
  long double div(BigNum other1, BigNum other2) {
    int s = value.size();
    long double current = value.back();
    if (s >= 2) {
      current += ((long double)value[s - 2]) / (long long)1e9;
    }
    if (s >= 3) {
      current +=
          ((long double)value[s - 3]) / ((long long)1e9 * (long long)1e9);
    }
    int s1 = other1.value.size();
    int s2 = other2.value.size();
    long double other = 0;
    if (s1 + s2 - 1 == s) {
      other += other1.value.back() * other2.value.back();
      if (s1 >= 2) {
        other += ((long double)other1.value[s1 - 2] * other2.value.back()) /
                 (long long)1e9;
      }
      if (s2 >= 2) {
        other += ((long double)other2.value[s2 - 2] * other1.value.back()) /
                 (long long)1e9;
      }
      if (s1 >= 3) {
        other += ((long double)other1.value[s1 - 3] * other2.value.back()) /
                 ((long long)1e9 * (long long)1e9);
      }
      if (s2 >= 3) {
        other += ((long double)other2.value[s2 - 3] * other1.value.back()) /
                 ((long long)1e9 * (long long)1e9);
      }
    }
    if (s1 + s2 - 1 == s - 1) {
      other += other1.value.back() * other2.value.back();
      if (s1 >= 2) {
        other += ((long double)other1.value[s1 - 2] * other2.value.back()) /
                 (long long)1e9;
      }
      if (s2 >= 2) {
        other += ((long double)other2.value[s2 - 2] * other1.value.back()) /
                 (long long)1e9;
      }
      other /= (long long)1e9;
    }
    if (s1 + s2 - 1 == s - 2) {
      other += other1.value.back() * other2.value.back();
      other /= (long long)1e9 * (long long)1e9;
    }
    return other / current;
  }
  string stringify() {
    string out = to_string(value.back());
    for (int i = value.size() - 1 - 1; i > -1; i -= 1) {
      string cur = to_string(value[i] + (long long)1e9);
      out += cur.substr(1);
    }
    return out;
  }
};
long long gcd(long long a, long long b) {
  if (b == 0) {
    return a;
  }
  return gcd(b, a % b);
}
long long triangle(long long x) { return ((x + 1) * x) / 2; }
long long antitriangle(long long x) {
  long long low = 0, high = 2 * 1000000007;
  while (low < high) {
    long long mid = (low + high + 1) / 2;
    if (triangle(mid) <= x) {
      low = mid;
    } else {
      high = mid - 1;
    }
  }
  return low;
}
long long modInverse(long long a) {
  long long m = 1000000007;
  long long y = 0, x = 1;
  while (a > 1) {
    long long q = a / m;
    long long t = m;
    m = a % m, a = t;
    t = y;
    y = x - q * y;
    x = t;
  }
  if (x < 0) {
    x += 1000000007;
  }
  return x;
}
long long modInverse(long long a, long long b) {
  long long m = b;
  long long y = 0, x = 1;
  while (a > 1) {
    long long q = a / m;
    long long t = m;
    m = a % m, a = t;
    t = y;
    y = x - q * y;
    x = t;
  }
  if (x < 0) {
    x += b;
  }
  return x;
}
long long pow(long long a, long long b) {
  if (b == 0) {
    return 1;
  }
  if (b % 2 == 0) {
    return pow((a * a) % 1000000007, b / 2) % 1000000007;
  }
  return (a * pow((a * a) % 1000000007, b / 2)) % 1000000007;
}
long long pow(long long a, long long b, long long m) {
  if (b == 0) {
    return 1;
  }
  if (b % 2 == 0) {
    return pow((a * a) % m, b / 2, m) % m;
  }
  return (a * pow((a * a) % m, b / 2, m)) % m;
}
vector<long long> dev(vector<pair<long long, long long> > divisors) {
  if (divisors.size() == 0) {
    vector<long long> cur;
    cur.push_back(1);
    return cur;
  }
  long long x = divisors.back().first;
  long long n = divisors.back().second;
  divisors.pop_back();
  vector<long long> ans = dev(divisors);
  vector<long long> cur;
  long long xi = 1;
  for (int i = 0; i < n + 1; i += 1) {
    for (int j = 0; j < ans.size(); j += 1) {
      cur.push_back(ans[j] * xi);
    }
    xi *= x;
  }
  return cur;
}
bool isprime(long long a) {
  if (a == 1) {
    return false;
  }
  for (int i = 2; i * i <= a; i++) {
    if (a % i == 0) {
      return false;
    }
  }
  return true;
}
void add(vector<int>& x, vector<int>& y) {
  for (int i = 0; i < x.size(); i += 1) {
    x[i] += y[i];
  }
}
vector<long long> mul(vector<long long> x, long long a) {
  for (int i = 0; i < x.size(); i += 1) {
    x[i] = (x[i] * a) % 1000000007;
  }
  return x;
}
vector<long long> add(vector<long long> x, vector<long long>& y) {
  for (int i = 0; i < x.size(); i += 1) {
    x[i] = (x[i] + y[i]) % 1000000007;
  }
  return x;
}
int lca(vector<vector<int> >& f, vector<int>& depth, int a, int b) {
  if (depth[a] < depth[b]) {
    swap(a, b);
  }
  for (int k = 0; k < 21; k += 1) {
    if ((depth[a] - depth[b]) & (1 << k)) {
      a = f[k][a];
    }
  }
  if (a == b) {
    return a;
  }
  for (int k = 21 - 1; k > -1; k -= 1) {
    if (f[k][a] != f[k][b]) {
      a = f[k][a];
      b = f[k][b];
    }
  }
  return f[0][a];
}
struct pt {
  long long x, y;
  long long d() const { return x * x + y * y; }
};
inline pt operator-(const pt& a) { return {-a.x, -a.y}; }
inline pt operator+(const pt& a, const pt& b) { return {a.x + b.x, a.y + b.y}; }
inline pt operator-(const pt& a, const pt& b) { return {a.x - b.x, a.y - b.y}; }
inline long long operator*(const pt& a, const pt& b) {
  return a.x * b.y - a.y * b.x;
}
inline bool operator<(const pt& a, const pt& b) {
  if (a * b != 0) return a * b < 0;
  return a.d() < b.d();
}
bool llll(const pt& a, const pt& b) { return a * b > 0; }
inline bool operator<=(const pt& a, const pt& b) { return a * b <= 0; }
inline long long operator/(const pt& a, const pt& b) {
  return a.x * b.x + a.y * b.y;
}
inline bool operator==(const pt& a, const pt& b) {
  return a.x == b.x && a.y == b.y;
}
inline bool operator!=(const pt& a, const pt& b) {
  return a.x != b.x || a.y != b.y;
}
struct stringtree {
  stringtree* sons[26];
  stringtree* father;
  int have[26];
  int num = 0;
  static int func(char a) { return a - 'a'; }
  stringtree(stringtree* f) {
    num = 0;
    for (int i = 0; i < 26; i += 1) {
      sons[i] = NULL;
      have[i] = 0;
    }
    father = f;
  }
  stringtree* add(int p, string& x) {
    if (x.size() == p) {
      num++;
      return this;
    }
    if (sons[func(x[p])] == NULL) {
      sons[func(x[p])] = new stringtree(this);
    }
    num++;
    return sons[func(x[p])]->add(p + 1, x);
  }
  stringtree* add(string x) { return add(0, x); }
  vector<int> find(int p, string& x) {
    if (p == x.size()) {
      vector<int> r;
      if (num) {
        r.push_back(p);
      }
      return r;
    }
    vector<int> r;
    if (sons[func(x[p])] != NULL) {
      r = sons[func(x[p])]->find(p + 1, x);
    }
    if (num) {
      r.push_back(p);
    }
    return r;
  }
  vector<int> find(string x) { return find(0, x); }
  void completeserch() {
    for (int i = 0; i < 26; i += 1) {
      if (sons[i] == NULL) {
        continue;
      }
      sons[i]->completeserch();
      for (int j = 0; j < 26; j += 1) {
        if (j != i) {
          have[j] += sons[i]->have[j];
        }
      }
      have[i] += sons[i]->num;
    }
  }
};
pt o = {0, 0};
bool comp(pt a, pt b) {
  if ((a - o) * (b - o) != 0) return (a - o) * (b - o) < 0;
  return (a - o).d() < (b - o).d();
}
bool decreasing(int a, int b) { return a > b; }
struct booleantree {
  booleantree* left = NULL;
  booleantree* right = NULL;
  void add(int val) {
    booleantree* cur = this;
    for (int i = 30 - 1; i > -1; i -= 1) {
      if ((val & (1 << i))) {
        if (cur->right == NULL) {
          cur->right = new booleantree();
        }
        cur = cur->right;
      } else {
        if (cur->left == NULL) {
          cur->left = new booleantree();
        }
        cur = cur->left;
      }
    }
  }
  int find(int val) {
    booleantree* cur = this;
    int ans = 0;
    for (int i = 30 - 1; i > -1; i -= 1) {
      if ((val & (1 << i))) {
        if (cur->left == NULL) {
          cur = cur->right;
        } else {
          cur = cur->left;
          ans += (1 << i);
        }
      } else {
        if (cur->right == NULL) {
          cur = cur->left;
        } else {
          cur = cur->right;
          ans += (1 << i);
        }
      }
    }
    return ans;
  }
};
struct segtremin {
  vector<vector<long long> > arr;
  int n;
  int curlogn;
  segtremin(int size, int logni) {
    n = size;
    curlogn = logni;
    arr.resize(curlogn);
    for (int i = 0; i < curlogn; i += 1) {
      arr[i].resize(size + 1);
    }
  }
  inline long long val(int start, int end) {
    if (end >= n) {
      end = n - 1;
    }
    if (start < 0) {
      start = 0;
    }
    long long mini = 8000000000000000007;
    for (int i = 0; i < curlogn; i += 1) {
      if (start > end) {
        break;
      }
      if ((end & 1) == 0) {
        mini = min(mini, arr[i][end]);
        ;
        end--;
        if (end < 0) {
          break;
        }
      }
      if ((start & 1)) {
        mini = min(mini, arr[i][start]);
        start++;
      }
      start /= 2;
      end /= 2;
    }
    return mini;
  }
  inline void add(int start, long long num) {
    arr[0][start] = num;
    for (int i = 1; i < curlogn; i += 1) {
      arr[i][start >> i] =
          min(arr[i - 1][(start >> i) * 2], arr[i - 1][(start >> i) * 2 + 1]);
    }
  }
};
struct segtresum {
  vector<vector<long long> > arr;
  int n;
  int curlogn;
  segtresum(int size, int logni) {
    n = size;
    curlogn = logni;
    arr.resize(curlogn);
    for (int i = 0; i < curlogn; i += 1) {
      arr[i].resize(size + 1);
    }
  }
  inline long long val(int start, int end) {
    if (end >= n) {
      end = n - 1;
    }
    if (start < 0) {
      start = 0;
    }
    long long mini = 0;
    for (int i = 0; i < curlogn; i += 1) {
      if (start > end) {
        break;
      }
      if ((end & 1) == 0) {
        mini += arr[i][end];
        end--;
        if (end < 0) {
          break;
        }
      }
      if ((start & 1)) {
        mini += arr[i][start];
        start++;
      }
      start /= 2;
      end /= 2;
    }
    return mini;
  }
  inline void add(int start, long long num) {
    arr[0][start] = num;
    for (int i = 1; i < curlogn; i += 1) {
      arr[i][start >> i] =
          arr[i - 1][(start >> i) * 2] + arr[i - 1][(start >> i) * 2 + 1];
    }
  }
};
string op(string s) {
  string ans;
  for (int i = s.size() - 1; i > -1; i -= 1) {
    ans.push_back(s[i]);
  }
  return ans;
}
void merge(vector<int>& color, vector<vector<int> >& allcolor, int l, int r) {
  if (color[l] == color[r]) {
    return;
  }
  l = color[l];
  r = color[r];
  if (allcolor[l].size() < allcolor[r].size()) {
    swap(l, r);
  }
  for (int j = 0; j < allcolor[r].size(); j += 1) {
    color[allcolor[r][j]] = l;
    allcolor[l].push_back(allcolor[r][j]);
  }
  allcolor[r].resize(0);
}
vector<pt> conv(vector<pt> a) {
  pt left = {99999999999999, 999999999999999};
  for (int i = 0; i < a.size(); i += 1) {
    if (a[i].x < left.x || a[i].x == left.x && a[i].y > left.y) {
      left = a[i];
    }
  }
  o = left;
  for (int i = 0; i < a.size(); i += 1) {
    if (a[i] == left) {
      a[i] = a.back();
      a.pop_back();
      break;
    }
  }
  sort(a.begin(), a.end(), comp);
  vector<pt> conv(1, left);
  for (int i = 0; i < a.size(); i += 1) {
    while (conv.size() > 1) {
      if ((a[i] - conv.back()) * (conv.back() - conv[conv.size() - 2]) <= 0) {
        conv.pop_back();
      } else {
        break;
      }
    }
    conv.push_back(a[i]);
  }
  while (conv.size() > 1) {
    if ((left - conv.back()) * (conv.back() - conv[conv.size() - 2]) <= 0) {
      conv.pop_back();
    } else {
      break;
    }
  }
  return conv;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  long long n;
  cin >> n;
  if (n % 2 == 0) {
    cout << "First" << endl;
    for (int i = 0; i < n; i += 1) {
      cout << (i + 1) << ' ';
    }
    for (int i = 0; i < n; i += 1) {
      cout << (i + 1) << ' ';
    }
    return 0;
  }
  cout << "Second" << endl;
  vector<int> sumpairs(n);
  vector<int> arr(2 * n);
  for (int i = 0; i < 2 * n; i += 1) {
    cin >> arr[i];
    arr[i]--;
    sumpairs[arr[i]] += i;
  }
  vector<int> choose(n, -1);
  int odd = -1;
  for (int i = 0; i < n; i += 1) {
    if (choose[i] != -1) {
      continue;
    }
    int count = 0;
    int cur = i;
    do {
      choose[cur % n] = cur;
      cur = sumpairs[arr[cur]] - cur;
      cur = (n + cur) % (2 * n);
      count++;
    } while (cur != i);
    if (count % 2 == 1) {
      odd = i;
    }
  }
  long long sum = 0;
  for (int i = 0; i < n; i += 1) {
    sum += choose[i];
  }
  if (sum % (2 * n) == 0) {
    int cur = odd;
    do {
      choose[cur % n] = (n + cur) % (2 * n);
      cur = sumpairs[arr[cur]] - cur;
      cur = (n + cur) % (2 * n);
    } while (cur != odd);
  }
  for (int i = 0; i < n; i += 1) {
    choose[i]++;
  }
  sort(choose.begin(), choose.end());
  for (int i = 0; i < n; i += 1) {
    cout << (choose[i]) << ' ';
  }
  cout << "" << '\n';
  return 0;
}
