import java.io.*;
import java.util.*;
public class Main {
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static String line;
    static int n, k, T, N, m, Q, q, R, C, x, M, id, x0, y0, g, y, d, SCC;
    static StringTokenizer st;
    static Scanner in = new Scanner(System.in);
    static char[][] word;
    static IP[][] parent;
    static BitSet onStack = new BitSet(100000);
    static ArrayList<Integer> graph[];
    static int[] low, ids;
    static Stack<Integer> stack;

    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine());pw.println(Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe");
            pw.flush();

        }
        static class IP {
            int row, col;

            public IP(int row, int col) {
                this.row = row;
                this.col = col;
            }
        }
        static void extendedEuclid ( int a, int b){
            if (b == 0) {
                x = 1;
                y = 0;
                d = a;
                return;
            }
            extendedEuclid(b, a % b);
            int x1 = y;
            int y1 = x - (a / b) * y;
            x = x1;
            y = y1;
        }
        static boolean isEven ( int i){
            return (i & 1) == 0;
        }
        static boolean isOdd ( int i){
            return (i & 1) == 1;
        }
        static class Edge implements Comparable<Edge> {
            int u, v;
            double weight;

            Edge(int u, int v, double weight) {
                this.u = u;
                this.v = v;
                this.weight = weight;
            }

            @Override
            public int compareTo(Edge edge) {
                return (int) (weight - (int) edge.weight);
            }
        }
        static class DisjointSet {
            int[] parent, rank;

            void make_set(int v) {
                parent = new int[v];
                for (int i = 0; i < v; i++)
                    parent[i] = i;
                rank = new int[v];
            }

            int find_set(int v) {
                if (v == parent[v])
                    return v;
                return parent[v] = find_set(parent[v]);//compress the step
            }

            void union_set(int a, int b) {
                a = find_set(a);
                b = find_set(b);
                if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                }
            }
        }
    }
 import java.io.*; io.* java import java.util.*; util.* java public class Main {
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static String line;
    static int n, k, T, N, m, Q, q, R, C, x, M, id, x0, y0, g, y, d, SCC;
    static StringTokenizer st;
    static Scanner in = new Scanner(System.in);
    static char[][] word;
    static IP[][] parent;
    static BitSet onStack = new BitSet(100000);
    static ArrayList<Integer> graph[];
    static int[] low, ids;
    static Stack<Integer> stack;

    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine());pw.println(Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe");
            pw.flush();

        }
        static class IP {
            int row, col;

            public IP(int row, int col) {
                this.row = row;
                this.col = col;
            }
        }
        static void extendedEuclid ( int a, int b){
            if (b == 0) {
                x = 1;
                y = 0;
                d = a;
                return;
            }
            extendedEuclid(b, a % b);
            int x1 = y;
            int y1 = x - (a / b) * y;
            x = x1;
            y = y1;
        }
        static boolean isEven ( int i){
            return (i & 1) == 0;
        }
        static boolean isOdd ( int i){
            return (i & 1) == 1;
        }
        static class Edge implements Comparable<Edge> {
            int u, v;
            double weight;

            Edge(int u, int v, double weight) {
                this.u = u;
                this.v = v;
                this.weight = weight;
            }

            @Override
            public int compareTo(Edge edge) {
                return (int) (weight - (int) edge.weight);
            }
        }
        static class DisjointSet {
            int[] parent, rank;

            void make_set(int v) {
                parent = new int[v];
                for (int i = 0; i < v; i++)
                    parent[i] = i;
                rank = new int[v];
            }

            int find_set(int v) {
                if (v == parent[v])
                    return v;
                return parent[v] = find_set(parent[v]);//compress the step
            }

            void union_set(int a, int b) {
                a = find_set(a);
                b = find_set(b);
                if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                }
            }
        }
    } Main static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out)); pw new PrintWriter(new OutputStreamWriter(System.out)) static BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); br new BufferedReader(new InputStreamReader(System.in)) static String line; line static int n n k k T T N N m m Q Q q q R R C C x x M M id id x0 x0 y0 y0 g g y y d d SCC; SCC static StringTokenizer st; st static Scanner in = new Scanner(System.in); in new Scanner(System.in) static char[][] word; word static IP[][] parent; parent static BitSet onStack = new BitSet(100000); onStack new BitSet(100000) static ArrayList<Integer> graph[]; graph static int[] low low ids; ids static Stack<Integer> stack; stack public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine());pw.println(Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe");
            pw.flush();

        } main {
        st = new StringTokenizer(br.readLine());pw.println(Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe");
            pw.flush();

        } st = new StringTokenizer(br.readLine()) st new StringTokenizer(br.readLine()) pw.println(Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe") pw.println pw Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe" Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken()) Integer.parseInt(st.nextToken()) Integer.parseInt Integer st.nextToken() st.nextToken st Integer.parseInt(st.nextToken()) Integer.parseInt Integer st.nextToken() st.nextToken st "safe" "unsafe" pw.flush() pw.flush pw String[] args args static void extendedEuclid ( int a, int b){
            if (b == 0) {
                x = 1;
                y = 0;
                d = a;
                return;
            }
            extendedEuclid(b, a % b);
            int x1 = y;
            int y1 = x - (a / b) * y;
            x = x1;
            y = y1;
        } extendedEuclid {
            if (b == 0) {
                x = 1;
                y = 0;
                d = a;
                return;
            }
            extendedEuclid(b, a % b);
            int x1 = y;
            int y1 = x - (a / b) * y;
            x = x1;
            y = y1;
        } if (b == 0) {
                x = 1;
                y = 0;
                d = a;
                return;
            } b == 0 b 0 {
                x = 1;
                y = 0;
                d = a;
                return;
            } x = 1 x 1 y = 0 y 0 d = a d a return; extendedEuclid(b, a % b) extendedEuclid b a % b a b int x1 = y; x1 y int y1 = x - (a / b) * y; y1 x - (a / b) * y x (a / b) * y (a / b) a b y x = x1 x x1 y = y1 y y1 int a a int b b static boolean isEven ( int i){
            return (i & 1) == 0;
        } isEven {
            return (i & 1) == 0;
        } return (i & 1) == 0; (i & 1) == 0 (i & 1) i 1 0 int i i static boolean isOdd ( int i){
            return (i & 1) == 1;
        } isOdd {
            return (i & 1) == 1;
        } return (i & 1) == 1; (i & 1) == 1 (i & 1) i 1 1 int i i static class IP {
            int row, col;

            public IP(int row, int col) {
                this.row = row;
                this.col = col;
            }
        } IP int row row col; col public IP(int row, int col) {
                this.row = row;
                this.col = col;
            } IP {
                this.row = row;
                this.col = col;
            } this.row = row this.row this this.row row this.col = col this.col this this.col col int row row int col col static class Edge implements Comparable<Edge> {
            int u, v;
            double weight;

            Edge(int u, int v, double weight) {
                this.u = u;
                this.v = v;
                this.weight = weight;
            }

            @Override
            public int compareTo(Edge edge) {
                return (int) (weight - (int) edge.weight);
            }
        } Edge int u u v; v double weight; weight Edge(int u, int v, double weight) {
                this.u = u;
                this.v = v;
                this.weight = weight;
            } Edge {
                this.u = u;
                this.v = v;
                this.weight = weight;
            } this.u = u this.u this this.u u this.v = v this.v this this.v v this.weight = weight this.weight this this.weight weight int u u int v v double weight weight @Override
            public int compareTo(Edge edge) {
                return (int) (weight - (int) edge.weight);
            } compareTo {
                return (int) (weight - (int) edge.weight);
            } return (int) (weight - (int) edge.weight); (int) (weight - (int) edge.weight) weight (int) edge.weight edge edge.weight Edge edge edge Comparable static class DisjointSet {
            int[] parent, rank;

            void make_set(int v) {
                parent = new int[v];
                for (int i = 0; i < v; i++)
                    parent[i] = i;
                rank = new int[v];
            }

            int find_set(int v) {
                if (v == parent[v])
                    return v;
                return parent[v] = find_set(parent[v]);//compress the step
            }

            void union_set(int a, int b) {
                a = find_set(a);
                b = find_set(b);
                if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                }
            }
        } DisjointSet int[] parent parent rank; rank void make_set(int v) {
                parent = new int[v];
                for (int i = 0; i < v; i++)
                    parent[i] = i;
                rank = new int[v];
            } make_set {
                parent = new int[v];
                for (int i = 0; i < v; i++)
                    parent[i] = i;
                rank = new int[v];
            } parent = new int[v] parent new int[v] v for (int i = 0; i < v; i++)
                    parent[i] = i; int i = 0; int i = 0; i 0 i < v i v i++ i++ i parent[i] = i; parent[i] = i parent[i] parent i i rank = new int[v] rank new int[v] v int v v int find_set(int v) {
                if (v == parent[v])
                    return v;
                return parent[v] = find_set(parent[v]);//compress the step
            } find_set {
                if (v == parent[v])
                    return v;
                return parent[v] = find_set(parent[v]);//compress the step
            } if (v == parent[v])
                    return v; v == parent[v] v parent[v] parent v return v; v return parent[v] = find_set(parent[v]);//compress the step parent[v] = find_set(parent[v]) parent[v] parent v find_set(parent[v]) find_set parent[v] parent v int v v void union_set(int a, int b) {
                a = find_set(a);
                b = find_set(b);
                if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                }
            } union_set {
                a = find_set(a);
                b = find_set(b);
                if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                }
            } a = find_set(a) a find_set(a) find_set a b = find_set(b) b find_set(b) find_set b if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                } a != b a b {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                } if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    } rank[a] < rank[b] rank[a] rank a rank[b] rank b {
                        int c = a;
                        a = b;
                        b = c;
                    } int c = a; c a a = b a b b = c b c parent[b] = a parent[b] parent b a if (rank[a] == rank[b])
                        rank[a]++; rank[a] == rank[b] rank[a] rank a rank[b] rank b rank[a]++ rank[a] rank a int a a int b b public class Main {
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static String line;
    static int n, k, T, N, m, Q, q, R, C, x, M, id, x0, y0, g, y, d, SCC;
    static StringTokenizer st;
    static Scanner in = new Scanner(System.in);
    static char[][] word;
    static IP[][] parent;
    static BitSet onStack = new BitSet(100000);
    static ArrayList<Integer> graph[];
    static int[] low, ids;
    static Stack<Integer> stack;

    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine());pw.println(Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe");
            pw.flush();

        }
        static class IP {
            int row, col;

            public IP(int row, int col) {
                this.row = row;
                this.col = col;
            }
        }
        static void extendedEuclid ( int a, int b){
            if (b == 0) {
                x = 1;
                y = 0;
                d = a;
                return;
            }
            extendedEuclid(b, a % b);
            int x1 = y;
            int y1 = x - (a / b) * y;
            x = x1;
            y = y1;
        }
        static boolean isEven ( int i){
            return (i & 1) == 0;
        }
        static boolean isOdd ( int i){
            return (i & 1) == 1;
        }
        static class Edge implements Comparable<Edge> {
            int u, v;
            double weight;

            Edge(int u, int v, double weight) {
                this.u = u;
                this.v = v;
                this.weight = weight;
            }

            @Override
            public int compareTo(Edge edge) {
                return (int) (weight - (int) edge.weight);
            }
        }
        static class DisjointSet {
            int[] parent, rank;

            void make_set(int v) {
                parent = new int[v];
                for (int i = 0; i < v; i++)
                    parent[i] = i;
                rank = new int[v];
            }

            int find_set(int v) {
                if (v == parent[v])
                    return v;
                return parent[v] = find_set(parent[v]);//compress the step
            }

            void union_set(int a, int b) {
                a = find_set(a);
                b = find_set(b);
                if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                }
            }
        }
    } public class Main {
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static String line;
    static int n, k, T, N, m, Q, q, R, C, x, M, id, x0, y0, g, y, d, SCC;
    static StringTokenizer st;
    static Scanner in = new Scanner(System.in);
    static char[][] word;
    static IP[][] parent;
    static BitSet onStack = new BitSet(100000);
    static ArrayList<Integer> graph[];
    static int[] low, ids;
    static Stack<Integer> stack;

    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine());pw.println(Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe");
            pw.flush();

        }
        static class IP {
            int row, col;

            public IP(int row, int col) {
                this.row = row;
                this.col = col;
            }
        }
        static void extendedEuclid ( int a, int b){
            if (b == 0) {
                x = 1;
                y = 0;
                d = a;
                return;
            }
            extendedEuclid(b, a % b);
            int x1 = y;
            int y1 = x - (a / b) * y;
            x = x1;
            y = y1;
        }
        static boolean isEven ( int i){
            return (i & 1) == 0;
        }
        static boolean isOdd ( int i){
            return (i & 1) == 1;
        }
        static class Edge implements Comparable<Edge> {
            int u, v;
            double weight;

            Edge(int u, int v, double weight) {
                this.u = u;
                this.v = v;
                this.weight = weight;
            }

            @Override
            public int compareTo(Edge edge) {
                return (int) (weight - (int) edge.weight);
            }
        }
        static class DisjointSet {
            int[] parent, rank;

            void make_set(int v) {
                parent = new int[v];
                for (int i = 0; i < v; i++)
                    parent[i] = i;
                rank = new int[v];
            }

            int find_set(int v) {
                if (v == parent[v])
                    return v;
                return parent[v] = find_set(parent[v]);//compress the step
            }

            void union_set(int a, int b) {
                a = find_set(a);
                b = find_set(b);
                if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                }
            }
        }
    } Main
import java.io.*;
import java.util.*;
public class Main {
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static String line;
    static int n, k, T, N, m, Q, q, R, C, x, M, id, x0, y0, g, y, d, SCC;
    static StringTokenizer st;
    static Scanner in = new Scanner(System.in);
    static char[][] word;
    static IP[][] parent;
    static BitSet onStack = new BitSet(100000);
    static ArrayList<Integer> graph[];
    static int[] low, ids;
    static Stack<Integer> stack;

    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine());pw.println(Integer.parseInt(st.nextToken())>Integer.parseInt(st.nextToken())
        ?"safe":"unsafe");
            pw.flush();

        }
        static class IP {
            int row, col;

            public IP(int row, int col) {
                this.row = row;
                this.col = col;
            }
        }
        static void extendedEuclid ( int a, int b){
            if (b == 0) {
                x = 1;
                y = 0;
                d = a;
                return;
            }
            extendedEuclid(b, a % b);
            int x1 = y;
            int y1 = x - (a / b) * y;
            x = x1;
            y = y1;
        }
        static boolean isEven ( int i){
            return (i & 1) == 0;
        }
        static boolean isOdd ( int i){
            return (i & 1) == 1;
        }
        static class Edge implements Comparable<Edge> {
            int u, v;
            double weight;

            Edge(int u, int v, double weight) {
                this.u = u;
                this.v = v;
                this.weight = weight;
            }

            @Override
            public int compareTo(Edge edge) {
                return (int) (weight - (int) edge.weight);
            }
        }
        static class DisjointSet {
            int[] parent, rank;

            void make_set(int v) {
                parent = new int[v];
                for (int i = 0; i < v; i++)
                    parent[i] = i;
                rank = new int[v];
            }

            int find_set(int v) {
                if (v == parent[v])
                    return v;
                return parent[v] = find_set(parent[v]);//compress the step
            }

            void union_set(int a, int b) {
                a = find_set(a);
                b = find_set(b);
                if (a != b) {
                    if (rank[a] < rank[b]) {
                        int c = a;
                        a = b;
                        b = c;
                    }
                    parent[b] = a;
                    if (rank[a] == rank[b])
                        rank[a]++;
                }
            }
        }
    }

