#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
const char SPACE = ' ', ENDL = '\n';
const int BASE = (int)1e9 + 7;
const int MODULO = BASE;
int ri() {
  int v;
  cin >> v;
  return v;
}
long long rll() {
  long long v;
  cin >> v;
  return v;
}
string rs() {
  string s;
  cin >> s;
  return s;
}
vector<int> rvi(int n) {
  vector<int> a(n);
  for (int i = 0; i < n; ++i) cin >> a[i];
  return a;
}
void read_graph(int n, int edges, vector<vector<int> >& graph,
                bool oriented = false) {
  graph.assign(n, vector<int>());
  for (int e = 0; e < edges; ++e) {
    int from = ri() - 1;
    int to = ri() - 1;
    graph[from].push_back(to);
    if (!oriented) graph[to].push_back(from);
  }
}
bool yn(bool result, string yes = "YES", string no = "NO") {
  cout << (result ? yes : no) << ENDL;
  return result;
}
int get_bit(int mask, int bit) { return (mask >> bit) & 1; }
int init_input() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  cout << setprecision(10) << fixed;
  int local_tests = 1;
  return local_tests;
}
template <class V>
class MinimumQueue {
 private:
  deque<pair<V, int> > q;

 public:
  MinimumQueue() {}
  void push(V value) {
    int cnt = 1;
    while (q.size() > 0) {
      pair<V, int> last = q.back();
      if (last.first > value) {
        cnt += last.second;
        q.pop_back();
      } else {
        break;
      }
    }
    q.push_back({value, cnt});
  }
  V min(V inf) {
    if (q.empty()) return inf;
    return q.front().first;
  }
  void poll() {
    if (q.empty()) return;
    auto& first = q.front();
    --first.second;
    if (0 == first.second) {
      q.pop_front();
    }
  }
};
void solve_test() {
  int tests = 1;
  while (tests-- > 0) {
    int total = ri();
    int n = ri();
    vector<int> lefts(n);
    vector<int> rights(n);
    for (int i = 0; i < n; ++i) {
      cin >> lefts[i] >> rights[i];
    }
    if (rights.back() < total + total) {
      ++n;
      lefts.push_back(total + total);
      rights.push_back(total + total);
    }
    const int inf = (int)1e9;
    const int f = 0, s = 1;
    const int st = 0, fn = 1;
    vector<vector<vector<int> > > dp(
        2, vector<vector<int> >(2, vector<int>(total + 1, inf)));
    dp[fn][f][0] = 0;
    for (int seg_index = 0; seg_index < n; ++seg_index) {
      int pd = lefts[seg_index] - (0 == seg_index ? 0 : rights[seg_index - 1]);
      for (int t = 0; t <= total; ++t) {
        dp[st][f][t] = inf;
        if (t >= pd) {
          dp[st][f][t] = min(dp[st][f][t], dp[fn][f][t - pd]);
        }
        dp[st][s][t] = dp[fn][s][t];
        dp[st][f][t] = min(dp[st][f][t], dp[st][s][t] + 1);
        dp[st][s][t] = min(dp[st][s][t], dp[st][f][t] + 1);
      }
      int ld = rights[seg_index] - lefts[seg_index];
      MinimumQueue<int> qf, qs;
      for (int d = 0; d <= ld; ++d) {
        qf.push(inf);
        qs.push(inf);
      }
      for (int t = 0; t <= total; ++t) {
        dp[fn][f][t] = inf;
        dp[fn][s][t] = inf;
        if (t >= ld) {
          dp[fn][f][t] = min(dp[fn][f][t], dp[st][f][t - ld]);
        }
        dp[fn][s][t] = min(dp[fn][s][t], dp[st][s][t]);
        qf.push(dp[st][f][t]);
        qs.push(dp[st][s][t]);
        qf.poll();
        qs.poll();
        dp[fn][f][t] = min(dp[fn][f][t], qs.min(inf) + 1);
        dp[fn][s][t] = min(dp[fn][s][t], qf.min(inf) + 1);
      }
    }
    int answer = min(dp[fn][f][total], dp[fn][s][total]);
    if (yn(answer < inf, "Full", "Hungry")) {
      cout << answer << ENDL;
    }
  }
}
int main() {
  int local_tests = init_input();
  for (int local_test = 0; local_test < local_tests; ++local_test) {
    solve_test();
  }
  return 0;
}
