Amr bought a new video game "Guess Your Way Out! II". The goal of the game is to find an exit from the maze that looks like a perfect binary tree of height *h*. The player is initially standing at the root of the tree and the exit from the tree is located at some leaf node.

Let's index all the nodes of the tree such that 
 -  The root is number 1 -  Each internal node *i* (*i* ≤ 2<sup class="upper-index">*h* - 1</sup> - 1) will have a left child with index = 2*i* and a right child with index = 2*i* + 1 
The level of a node is defined as 1 for a root, or 1 + level of parent of the node otherwise. The vertices of the level *h* are called leaves. The exit to the maze is located at some leaf node *n*, the player doesn't know where the exit is so he has to guess his way out! 

In the new version of the game the player is allowed to ask questions on the format "Does the *ancestor*(*exit*, *i*) node number belong to the range [*L*, *R*]?". Here *ancestor*(*v*, *i*) is the ancestor of a node *v* that located in the level *i*. The game will answer with "Yes" or "No" only. The game is designed such that it doesn't always answer correctly, and sometimes it cheats to confuse the player!.

Amr asked a lot of questions and got confused by all these answers, so he asked you to help him. Given the questions and its answers, can you identify whether the game is telling contradictory information or not? If the information is not contradictory and the exit node can be determined uniquely, output its number. If the information is not contradictory, but the exit node isn't defined uniquely, output that the number of questions is not sufficient. Otherwise output that the information is contradictory.
The first line contains two integers *h*, *q* (1 ≤ *h* ≤ 50, 0 ≤ *q* ≤ 10<sup class="upper-index">5</sup>), the height of the tree and the number of questions respectively.

The next *q* lines will contain four integers each *i*, *L*, *R*, *ans* (1 ≤ *i* ≤ *h*, 2<sup class="upper-index">*i* - 1</sup> ≤ *L* ≤ *R* ≤ 2<sup class="upper-index">*i*</sup> - 1, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/efee5db22bd8e5a4848907ab50b074b75fa6f3c7.png" style="max-width: 100.0%;max-height: 100.0%;"/>), representing a question as described in the statement with its answer (*ans* = 1 if the answer is "Yes" and *ans* = 0 if the answer is "No").
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def ReadIn():
    height, n = [int(x) for x in input().split()]
    queries = [tuple(int(x) for x in input().split())
               for q in range(n)]
    return height, queries

def MoveToLeaves(height, queries):
    leaves = []
    for level, left, right, yn in queries:
        shift = height - level
        leaves.append(tuple([
            left << shift,
            (right << shift) | ((1 << shift) - 1),
            yn]))
    return leaves

def RangeIntersection(ranges):
    # print(ranges)
    ret = ranges[0][:2]
    for r in ranges:
        ret = (max(r[0], ret[0]), min(r[1], ret[1]))
    return ret

def RangeUnion(ranges):
    if len(ranges) == 0: return []
    ranges.sort(key=lambda r: r[0])
    ret = []
    now = ranges[0][:2]
    for r in ranges:
        if r[0] > now[1] + 1:
            ret.append(now)
            now = r
        else:
            now = (now[0], r[1])
    ret.append(now)
    return ret

def Solve(height, queries):
    # print(height, queries)
    queries = MoveToLeaves(height, queries)
    # print(queries)
    range_in = RangeIntersection(
        [(1 << (height - 1), (1 << height) - 1, 1)] +
        list(filter(lambda q: q[2] == 1, queries)))
    # print(range_in)
    ranges_out = RangeUnion(
        list(filter(lambda q: q[2] == 0, queries)))
    # print(ranges_out)
    if range_in[0] > range_in[1]:
        print('Game cheated!')
        return
    for r in ranges_out:
        if r[0] <= range_in[0] and range_in[1] <= r[1]:
            print('Game cheated!')
            return
        if range_in[0] < r[0] and r[1] < range_in[1]:
            print('Data not sufficient!')
            return
    for r in ranges_out:
        if r[0] == range_in[0] + 1:
            print(range_in[0])
            return
        if r[1] == range_in[1] - 1:
            print(range_in[1])
            return
    for l, r in zip(ranges_out[:-1], ranges_out[1:]):
        if r[0] - l[1] == 2: continue
        pos = l[0] + 1
        if range_in[0] <= pos <= range_in[1]:
            print(pos)
            return
    print('Data not sufficient!')

if __name__ == '__main__':
    height, queries = ReadIn()
    Solve(height, queries)