Problem:
Score : 100 points

Problem Statement

There are S sheep and W wolves.

If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.

If the wolves will attack the sheep, print unsafe; otherwise, print safe.

Constraints

1 \leq S \leq 100

1 \leq W \leq 100

Input

Input is given from Standard Input in the following format:

S W

Output

If the wolves will attack the sheep, print unsafe; otherwise, print safe.

Sample Input 1

4 5

Sample Output 1

unsafe

There are four sheep and five wolves. The number of wolves is not less than that of sheep, so they will attack them.

Sample Input 2

100 2

Sample Output 2

safe

Many a sheep drive away two wolves.

Sample Input 3

10 10

Sample Output 3

unsafe

Solution in C++ (GCC 9.2.1) (judge verdict: Accepted)

#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

#define LLint long long int
#define Lint long int
#define Ldouble long double

// class UnionFind;

// bool sortBySec(const pair<int, int>& a, const pair<int, int>& b);
// int modExp(int x, int n, int m);
// int mmi(int x, int m);

int s, w;

void solve() {
    cin >> s >> w;
    if (w >= s) {
        cout << "unsafe";
    }
    else {
        cout << "safe";
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    solve();

    return EXIT_SUCCESS;
}

// Helpers.
/*
bool sortBySec(const pair<int, int>& a, const pair<int, int>& b) {
    return (a.second < b.second);
}
*/
// Modular arithmetic.
/*
int modExp(const int x, const int n, const int m) {
    if (n == 0) {
        return 1;
    }
    LLint u = modExp(x, n / 2, m);
    return n % 2 == 0 ? (u * u) % m : (((u * u) % m) * x) % m;
}
*/
/*
int mmi(const int x, const int m) { return modExp(x, m - 2, m); }
*/
// Union find data structure.
/*
class UnionFind {
   public:
    vector<int> link;
    vector<int> size;

    UnionFind(int n) {
        link = vector<int>(n);
        size = vector<int>(n);
        for (int i = 0; i < n; i++) {
            link[i] = i;
            size[i] = 1;
        }
    }

    int find(int x) {
        while (x != link[x]) {
            x = link[x];
        }
        return x;
    }

    bool same(int a, int b) { return find(a) == find(b); }

    void unite(int a, int b) {
        a = find(a);
        b = find(b);
        if (size[a] < size[b]) {
            swap(a, b);
        }
        size[a] += size[b];
        link[b] = a;
    }
};
*/