Problem: One day Igor K. stopped programming and took up math. One late autumn evening he was sitting at a table reading a book and thinking about something. 

The following statement caught his attention: "Among any six people there are either three pairwise acquainted people or three pairwise unacquainted people"

Igor just couldn't get why the required minimum is 6 people. "Well, that's the same for five people, too!" — he kept on repeating in his mind. — "Let's take, say, Max, Ilya, Vova — here, they all know each other! And now let's add Dima and Oleg to Vova — none of them is acquainted with each other! Now, that math is just rubbish!"

Igor K. took 5 friends of his and wrote down who of them is friends with whom. Now he wants to check whether it is true for the five people that among them there are either three pairwise acquainted or three pairwise not acquainted people.

Input

The first line contains an integer m (0 ≤ m ≤ 10), which is the number of relations of acquaintances among the five friends of Igor's.

Each of the following m lines contains two integers ai and bi (1 ≤ ai, bi ≤ 5;ai ≠ bi), where (ai, bi) is a pair of acquainted people. It is guaranteed that each pair of the acquaintances is described exactly once. The acquaintance relation is symmetrical, i.e. if x is acquainted with y, then y is also acquainted with x.

Output

Print "FAIL", if among those five people there are no either three pairwise acquainted or three pairwise unacquainted people. Otherwise print "WIN".

Examples

Input

4
1 3
2 3
1 4
5 3


Output

WIN


Input

5
1 2
2 3
3 4
4 5
5 1


Output

FAIL

Solution (in PYTHON3):

Solution:
#!/usr/bin/env python
from __future__ import division, print_function
import math
import os
import sys
from fractions import *
from sys import stdin,stdout
from io import BytesIO, IOBase
from itertools import accumulate
from collections import deque
#sys.setrecursionlimit(10**5)

def inp(): return sys.stdin.readline().rstrip("\r\n")  # for fast input

def out(var): sys.stdout.write(str(var))  # for fast output, always take string

def lis(): return list(map(int, inp().split()))

def stringlis(): return list(map(str, inp().split()))

def sep(): return map(int, inp().split())

def strsep(): return map(str, inp().split())

def fsep(): return map(float, inp().split())

def inpu(): return int(inp())

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
#sys.setrecursionlimit(10**6)

# region fastio

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")
#-----------------------------------------------------------------

def regularbracket(t):
    p=0
    for i in t:
        if i=="(":
            p+=1
        else:
            p-=1
        if p<0:
            return False
    else:
        if p>0:
            return False
        else:
            return True

#-------------------------------------------------
def binarySearchCount(arr, n, key):
    left = 0
    right = n - 1

    count = 0

    while (left <= right):
        mid = int((right + left) / 2)

        # Check if middle element is
        # less than or equal to key
        if (arr[mid] <= key):
            count = mid+1
            left = mid + 1

        # If key is smaller, ignore right half
        else:
            right = mid - 1
    return count
#------------------------------reverse string(pallindrome)
def reverse1(string):
    pp=""
    for i in string[::-1]:
        pp+=i
    if pp==string:
        return True
    return False
#--------------------------------reverse list(paindrome)
def reverse2(list1):
    l=[]
    for i in list1[::-1]:
        l.append(i)
    if l==list1:
        return True
    return False
def mex(list1):
    #list1 = sorted(list1)
    p = max(list1)+1
    for i in range(len(list1)):
        if list1[i]!=i:
            p = i
            break
    return p
def sumofdigits(n):
    n = str(n)
    s1=0
    for i in n:
        s1+=int(i)
    return s1
def perfect_square(n):
    s = math.sqrt(n)
    if s==int(s):
        return True
    return False

#-----------------------------roman
def roman_number(x):
    if x>15999:
        return
    value=[5000,4000,1000,900,500,400,100,90,50,40,10,9,5,4,1]
    symbol = ["F","MF","M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"]
    roman=""
    i=0
    while x>0:
        div = x//value[i]
        x = x%value[i]
        while div:
            roman+=symbol[i]
            div-=1
        i+=1
    return roman

def soretd(s):
    for i in range(1,len(s)):
        if s[i-1]>s[i]:
            return False
    return True
#print(soretd("1"))
#---------------------------
def countRhombi(h, w):
    ct = 0
    for i in range(2, h + 1, 2):
        for j in range(2, w + 1, 2):
            ct += (h - i + 1) * (w - j + 1)
    return ct
#---------------------------------
def binpow(a,b):
    if b==0:
        return 1
    else:
        res=binpow(a,b//2)
    if b%2!=0:
        return res*res*a
    else:
        return res*res
#-------------------------------------------------------
def binpowmodulus(a,b,m):
    a %= m
    res = 1
    while (b > 0):
        if (b & 1):
            res = res * a % m
        a = a * a % m
        b >>= 1
    return res
#-------------------------------------------------------------
def coprime_to_n(n):
    result = n
    i=2
    while(i*i<=n):
        if (n % i == 0):
            while (n % i == 0):
                n //= i
            result -= result // i
        i+=1
    if (n > 1):
        result -= result // n
    return result
#-------------------prime
def prime(x):
    if x==1:
        return False
    else:
        for i in range(2,int(math.sqrt(x))+1):
            if(x%i==0):
                return False
        else:
            return True

def luckynumwithequalnumberoffourandseven(x,n,a):
    if x >= n and str(x).count("4") == str(x).count("7"):
        a.append(x)
    else:
        if x < 1e12:
            luckynumwithequalnumberoffourandseven(x * 10 + 4,n,a)
            luckynumwithequalnumberoffourandseven(x * 10 + 7,n,a)
    return a

#def mapu(): return map(int,input().split())
#endregion------------------------------
"""
def main():
    x,y,n = sep()

    c = (Fraction(x,y).limit_denominator(n))
   # print(type(c))
   # print(c)
    c = str(c)
    if "/" in c:
            print(c)
    else:
            print(c+"/"+"1")

if __name__ == '__main__':
    main()
"""
"""
if __name__ == '__main__':
    a,b = sep()
    print(countRhombi(a,b))
"""
def main():
    m = inpu()
    l=[0]*5
    for _ in range(m):
        a,b = sep()
        l[a - 1] += 1
        l[b - 1] += 1
    #print(l)
    if l.count(2) == 5:
        print('FAIL')
    else:
            print('WIN')
if __name__ == '__main__':
    main()