#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
const int N = 2e5 + 10;
int dp[2][N][2];
int sp[2][N][18][2];
int d[N];
void build(int x, int k) {
  x = x & 1;
  for (int i = 0; i < N; i += 2) sp[0][i][0][k] = dp[x][i][k];
  for (int i = 1; i < N; i += 2) sp[1][i][0][k] = dp[x][i][k];
  for (int j = 1; j < 18; j++) {
    for (int i = 0; i + (1 << (j - 1)) < N; i++) {
      sp[0][i][j][k] =
          min(sp[0][i][j - 1][k], sp[0][i + (1 << (j - 1))][j - 1][k]);
      sp[1][i][j][k] =
          min(sp[1][i][j - 1][k], sp[1][i + (1 << (j - 1))][j - 1][k]);
    }
  }
}
int query(int i, int j, int l) {
  if (i > j) return INF;
  int z = i & 1;
  int k = d[j - i];
  int x = min(sp[z][i][k][l], sp[z][j - (1 << k) + 1][k][l]);
  return x;
}
vector<int> pct;
int extra = 0;
int n, k, off;
int main() {
  d[0] = d[1] = 0;
  for (int i = 2; i < N; i++) d[i] = d[i >> 1] + 1;
  memset(dp, INF, sizeof(dp));
  memset(sp, INF, sizeof(sp));
  scanf("%d %d", &n, &k);
  int b = 0;
  pct.push_back(0);
  for (int i = 0; i < k; i++) {
    int l, r;
    scanf("%d %d", &l, &r);
    pct.push_back(l - b);
    pct.push_back(r - l);
    if (i == k - 1) pct.push_back(2 * n - r);
    b = r;
  }
  dp[0][n][0] = 0;
  int at, last;
  for (int i = 1; i < pct.size(); i++) {
    at = i & 1;
    last = (i - 1) & 1;
    if (at) {
      for (int j = 0; j <= 2 * n; j++) {
        dp[at][j][0] = INF;
        dp[at][j][1] = INF;
        if (j - pct[i] >= 0) {
          dp[at][j][0] = min(dp[at][j][0], dp[last][j - pct[i]][1] + 1);
          dp[at][j][0] = min(dp[at][j][0], dp[last][j - pct[i]][0]);
        }
        if (j + pct[i] <= 2 * n) {
          dp[at][j][1] = min(dp[at][j][1], dp[last][j + pct[i]][1]);
          dp[at][j][1] = min(dp[at][j][1], dp[last][j + pct[i]][0] + 1);
        }
      }
    } else {
      build(i - 1, 0);
      build(i - 1, 1);
      int p = pct[i];
      int l, r, zero, um;
      for (int j = 0; j <= 2 * n; j++) {
        dp[at][j][0] = INF;
        dp[at][j][1] = INF;
        l = max(0, j - p);
        r = min(2 * n, j + p);
        zero = query(l, r, 0);
        um = query(l, r, 1);
        dp[at][j][0] = min(dp[at][j][0], zero + 2);
        if (j - p >= 0) {
          dp[at][j][0] = min(dp[at][j][0], dp[last][j - p][0]);
        }
        dp[at][j][0] = min(dp[at][j][0], um + 1);
        dp[at][j][1] = min(dp[at][j][1], um + 2);
        if (j + p <= 2 * n) {
          dp[at][j][1] = min(dp[at][j][1], dp[last][j + p][1]);
        }
        dp[at][j][1] = min(dp[at][j][1], zero + 1);
      }
    }
  }
  int x = pct.size() - 1;
  int r = min(dp[x & 1][n][0], dp[x & 1][n][1]);
  if (r == INF) {
    puts("Hungry");
  } else {
    puts("Full");
    printf("%d\n", r);
  }
  return 0;
}
