def main():
    import sys
    input = sys.stdin.read().split()
    ptr = 0
    N = int(input[ptr])
    ptr += 1
    M = int(input[ptr])
    ptr += 1

    groups = []
    B_list = []
    for _ in range(N):
        A = int(input[ptr])
        ptr += 1
        B = int(input[ptr])
        ptr += 1
        C = int(input[ptr])
        ptr += 1
        groups.append((A, C))
        B_list.append(B)

    # Precompute lower and upper for each group
    lower = []
    upper = []
    for A, C in groups:
        lower_i = min(A, C)
        upper_i = max(A, C)
        lower.append(lower_i)
        upper.append(upper_i)

    # Check if any group has no possible B_j
    possible = True
    for i in range(N):
        has_possible = False
        for B_j in B_list:
            if B_j < lower[i] or B_j > upper[i]:
                has_possible = True
                break
        if not has_possible:
            possible = False
            break
    if not possible:
        print("NO")
        return

    sum_upper = sum(upper)

    # Sort groups by upper_i in ascending order
    sorted_groups = sorted([(upper[i], i) for i in range(N)], key=lambda x: x[0])
    group_order = [i for (u, i) in sorted_groups]

    # Sort B's in descending order
    sorted_B = sorted(B_list, reverse=True)

    assigned = [False] * N
    sum_gain = 0

    for B in sorted_B:
        for idx in group_order:
            if not assigned[idx] and B > upper[idx]:
                sum_gain += (B - upper[idx])
                assigned[idx] = True
                break

    total = sum_upper + sum_gain

    print("YES")
    if total >= M:
        print("KADOMATSU!")
    else:
        print("NO")

if __name__ == "__main__":
    main()