Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
n, m = map(int, input().split())

edges = [set() for _ in range(n)]

for _ in range(m):
    s, t = map(int, input().split())
    edges[s].add(t)
    edges[t].add(s)

prenum = [None] * n
parent = [None] * n
lowest = [None] * n
counter = 0


def dfs(cur, prev):
    global counter
    prenum[cur] = lowest[cur] = counter
    counter += 1
    for edge in edges[cur]:
        if prenum[edge] is not None:
            if edge != prev:
                lowest[cur] = min(lowest[cur], prenum[edge])
            continue
        parent[edge] = cur
        dfs(edge, cur)
        lowest[cur] = min(lowest[cur], lowest[edge])


dfs(0, 1)
ap = [False] * n
r = 0
for _ in filter(lambda x: x == 0, parent):
    r += 1
    if r > 1:
        ap[0] = True
        break

for i in range(1, n):
    p = parent[i]
    if p and prenum[p] <= lowest[i]:
        ap[p] = True

for i, e in enumerate(ap):
    if e: print(i)

Fixed submission:
import sys

sys.setrecursionlimit(200000)

n, m = map(int, input().split())

edges = [set() for _ in range(n)]

for _ in range(m):
    s, t = map(int, input().split())
    edges[s].add(t)
    edges[t].add(s)

prenum = [None] * n
parent = [None] * n
lowest = [None] * n
counter = 0


def dfs(cur, prev):
    global counter
    prenum[cur] = lowest[cur] = counter
    counter += 1
    for edge in edges[cur]:
        if prenum[edge] is not None:
            if edge != prev:
                lowest[cur] = min(lowest[cur], prenum[edge])
            continue
        parent[edge] = cur
        dfs(edge, cur)
        lowest[cur] = min(lowest[cur], lowest[edge])


dfs(0, 1)
ap = [False] * n
r = 0
for _ in filter(lambda x: x == 0, parent):
    r += 1
    if r > 1:
        ap[0] = True
        break

for i in range(1, n):
    p = parent[i]
    if p and prenum[p] <= lowest[i]:
        ap[p] = True

for i, e in enumerate(ap):
    if e: print(i)
Buggy python submission (verdict: Runtime Error):
n, m = map(int, input().split())

edges = [set() for _ in range(n)]

for _ in range(m):
    s, t = map(int, input().split())
    edges[s].add(t)
    edges[t].add(s)

prenum = [None] * n
parent = [None] * n
lowest = [None] * n
counter = 0
bridges = set()


def dfs(cur, prev):
    global counter
    prenum[cur] = lowest[cur] = counter
    counter += 1
    for edge in edges[cur]:
        if prenum[edge] is not None:
            if edge != prev:
                lowest[cur] = min(lowest[cur], prenum[edge])
            continue
        parent[edge] = cur
        dfs(edge, cur)
        lowest[cur] = min(lowest[cur], lowest[edge])
    if prenum[cur] == lowest[cur]:
        bridges.add((cur, prev) if cur < prev else (prev, cur))


dfs(0, -1)

for bridge in sorted(bridges)[1:]:
    print(*bridge)

Fixed submission:
import sys

sys.setrecursionlimit(200000)

n, m = map(int, input().split())

edges = [set() for _ in range(n)]

for _ in range(m):
    s, t = map(int, input().split())
    edges[s].add(t)
    edges[t].add(s)

prenum = [None] * n
parent = [None] * n
lowest = [None] * n
counter = 0
bridges = set()


def dfs(cur, prev):
    global counter
    prenum[cur] = lowest[cur] = counter
    counter += 1
    for edge in edges[cur]:
        if prenum[edge] is not None:
            if edge != prev:
                lowest[cur] = min(lowest[cur], prenum[edge])
            continue
        parent[edge] = cur
        dfs(edge, cur)
        lowest[cur] = min(lowest[cur], lowest[edge])
    if prenum[cur] == lowest[cur]:
        bridges.add((cur, prev) if cur < prev else (prev, cur))


dfs(0, -1)

for bridge in sorted(bridges)[1:]:
    print(*bridge)
Buggy python submission (verdict: Runtime Error):
def f_dfs(i):
    global f_edges, counter
    visited[i] = True
    for edge in f_edges[i]:
        if visited[edge]:
            continue
        f_dfs(edge)
    finish_order[i] = (counter, i)
    counter += 1


def b_dfs(i, group):
    global b_edges, groups
    visited[i] = True
    groups[i] = group
    for edge in b_edges[i]:
        if visited[edge]:
            continue
        b_dfs(edge, group)


n, m = map(int, input().split())

f_edges = [set() for _ in range(n)]
b_edges = [set() for _ in range(n)]

for _ in range(m):
    s, t = map(int, input().split())
    f_edges[s].add(t)
    b_edges[t].add(s)

visited = [False] * n
finish_order = [None] * n
counter = 0

for i in range(n):
    if not visited[i]:
        f_dfs(i)

visited = [False] * n
groups = [None] * n
group = 0

for d, i in sorted(finish_order, reverse=True):
    if not visited[i]:
        b_dfs(i, group)
        group += 1

q = int(input())

while q:
    q -= 1
    u, v = map(int, input().split())
    print(int(groups[u] == groups[v]))

Fixed submission:
import sys

sys.setrecursionlimit(200000)


def f_dfs(i):
    global f_edges, counter
    visited[i] = True
    for edge in f_edges[i]:
        if visited[edge]:
            continue
        f_dfs(edge)
    finish_order[i] = (counter, i)
    counter += 1


def b_dfs(i, group):
    global b_edges, groups
    visited[i] = True
    groups[i] = group
    for edge in b_edges[i]:
        if visited[edge]:
            continue
        b_dfs(edge, group)


n, m = map(int, input().split())

f_edges = [set() for _ in range(n)]
b_edges = [set() for _ in range(n)]

for _ in range(m):
    s, t = map(int, input().split())
    f_edges[s].add(t)
    b_edges[t].add(s)

visited = [False] * n
finish_order = [None] * n
counter = 0

for i in range(n):
    if not visited[i]:
        f_dfs(i)

visited = [False] * n
groups = [None] * n
group = 0

for d, i in sorted(finish_order, reverse=True):
    if not visited[i]:
        b_dfs(i, group)
        group += 1

q = int(input())

while q:
    q -= 1
    u, v = map(int, input().split())
    print(int(groups[u] == groups[v]))
Buggy python submission (verdict: Runtime Error):
import sys

sys.setrecursionlimit(200000)


def dfs(i):
    global edges, visited, root, duplicated
    visited[i] = True
    for edge in edges[i]:
        if visited[edge]:
            if edge == root:
                return True
            duplicated.add(edge)
            continue
        if dfs(edge):
            return True


n, m = map(int, input().split())

edges = [set() for _ in range(n)]

for _ in range(m):
    s, t = map(int, input().split())
    edges[s].add(t)

visited = [False] * n
root = 0
duplicated = set()

for i in range(n):
    if not visited[i]:
        root = i
        if dfs(i):
            print(1)
            break
else:
    for i in duplicated:
        root = i
        if dfs(i):
            print(1)
            break
    else:
        print(0)

Fixed submission:
import sys

sys.setrecursionlimit(200000)


def do_dfs(root, add_duplicated=True):
    global edges, visited, duplicated

    def main(i):
        visited[i] = True
        for edge in edges[i]:
            if visited[edge]:
                if edge == root:
                    return True
                if add_duplicated:
                    duplicated.add(edge)
                continue
            if main(edge):
                return True
        return False

    return main(root)


n, m = map(int, input().split())

edges = [set() for _ in range(n)]

for _ in range(m):
    s, t = map(int, input().split())
    edges[s].add(t)

visited = [False] * n
duplicated = set()

for i in range(n):
    if not visited[i]:
        if do_dfs(i):
            print(1)
            break
else:
    for i in duplicated:
        visited = [False] * n
        if do_dfs(i, False):
            print(1)
            break
    else:
        print(0)
Buggy python submission (verdict: Runtime Error):
import sys
from operator import itemgetter

sys.setrecursionlimit(200000)


def dfs(u, prev):
    global post_order, pre_order

    pre_order.append((u, prev))
    for w, t in edges[u]:
        if t != prev:
            dfs(t, u)
    post_order.append(u)


n = int(input())
edges = [set() for _ in range(n)]

for _ in range(n - 1):
    s, t, w = map(int, input().split())
    edges[s].add((w, t))
    edges[t].add((w, s))

post_order, pre_order = [], []
farthest = [{} for _ in range(n)]
height = [0] * n

dfs(0, None)

for i in post_order:
    for w, t in edges[i]:
        farthest[i][t] = w + max((d for tt, d in farthest[t].items() if tt != i), default=0)
for i, parent in pre_order:
    sorted_farthest = sorted(farthest[i].items(), key=itemgetter(1))
    max_t, max_d = sorted_farthest.pop()
    height[i] = max_d
    for w, t in edges[i]:
        if t == parent:
            continue
        farthest[t][i] = w + ((max_d if t != max_t else sorted_farthest[-1][1]) if sorted_farthest else 0)
for h in height:
    print(h)

Fixed submission:
import sys
from operator import itemgetter

sys.setrecursionlimit(200000)


def dfs(u, prev):
    global post_order, pre_order

    pre_order.append((u, prev))
    for w, t in edges[u]:
        if t != prev:
            dfs(t, u)
    post_order.append(u)


n = int(input())
edges = [set() for _ in range(n)]

for _ in range(n - 1):
    s, t, w = map(int, input().split())
    edges[s].add((w, t))
    edges[t].add((w, s))

post_order, pre_order = [], []
farthest = [{} for _ in range(n)]
height = [0] * n

if n > 1:
    dfs(0, None)

for i in post_order:
    for w, t in edges[i]:
        farthest[i][t] = w + max((d for tt, d in farthest[t].items() if tt != i), default=0)
for i, parent in pre_order:
    sorted_farthest = sorted(farthest[i].items(), key=itemgetter(1))
    max_t, max_d = sorted_farthest.pop()
    height[i] = max_d
    for w, t in edges[i]:
        if t == parent:
            continue
        farthest[t][i] = w + ((max_d if t != max_t else sorted_farthest[-1][1]) if sorted_farthest else 0)
for h in height:
    print(h)
Buggy python submission (verdict: Runtime Error):
from heapq import heappop, heappush


def trace(source, edge_trace):
    v = source
    for i in edge_trace:
        e = edges[v][i]
        yield e
        v = e[1]


def min_cost_flow(source, sink, required_flow):
    res = 0
    while required_flow:
        visited = set()
        queue = [(0, source, tuple())]
        while queue:
            total_cost, v, edge_memo = heappop(queue)
            if v in visited:
                continue
            elif v == sink:
                dist = total_cost
                edge_trace = edge_memo
                break
            for i, (remain, target, cost, _) in enumerate(edges[v]):
                if remain and target not in visited:
                    heappush(queue, (total_cost + cost, target, edge_memo + (i,)))
        else:
            return -1

        aug = min(required_flow, min(e[0] for e in trace(source, edge_trace)))
        required_flow -= aug
        res += aug * dist
        for e in trace(source, edge_trace):
            remain, target, cost, idx = e
            e[0] -= aug
            edges[target][idx][0] += aug
    return res


n, m, f = map(int, input().split())
edges = [[] for _ in range(n)]

for _ in range(m):
    s, t, c, d = map(int, input().split())
    es, et = edges[s], edges[t]
    ls, lt = len(es), len(et)
    es.append([c, t, d, lt])
    et.append([0, s, d, ls])

print(min_cost_flow(0, n - 1, f))

Fixed submission:
INF = float('inf')


def trace_back(sink, predecessors):
    p = predecessors[sink]
    while p is not None:
        v, i = p
        yield edges[v][i]
        p = predecessors[v]


def min_cost_flow(source, sink, required_flow):
    res = 0
    while required_flow:
        dist = [INF] * n
        dist[source] = 0
        predecessors = [None] * n

        while True:
            updated = False
            for v in range(n):
                if dist[v] == INF:
                    continue
                for i, (remain, target, cost, _) in enumerate(edges[v]):
                    new_dist = dist[v] + cost
                    if remain and dist[target] > new_dist:
                        dist[target] = new_dist
                        predecessors[target] = (v, i)
                        updated = True
            if not updated:
                break

        if dist[sink] == INF:
            return -1

        aug = min(required_flow, min(e[0] for e in trace_back(sink, predecessors)))
        required_flow -= aug
        res += aug * dist[sink]
        for e in trace_back(sink, predecessors):
            remain, target, cost, idx = e
            e[0] -= aug
            edges[target][idx][0] += aug
    return res


n, m, f = map(int, input().split())
edges = [[] for _ in range(n)]

for _ in range(m):
    s, t, c, d = map(int, input().split())
    es, et = edges[s], edges[t]
    ls, lt = len(es), len(et)
    es.append([c, t, d, lt])
    et.append([0, s, -d, ls])

print(min_cost_flow(0, n - 1, f))
Buggy python submission (verdict: Runtime Error):
from math import sqrt

x1, y1, x2, y2 = map(int, input().split())
print(sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))

Fixed submission:
from math import sqrt

x1, y1, x2, y2 = map(float, input().split())
print(sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))
Buggy python submission (verdict: Runtime Error):
def cache_dice(d):
    return dlist.append((d, {v: k for k, v in enumerate(d)}))


n, d1 = int(input()), tuple(map(int, input().split()))
dlist = []

cache_dice(d1)

dms = ((1, 2, 4, 3), (0, 3, 5, 2), (0, 1, 5, 4), (0, 4, 5, 1), (0, 2, 5, 3), (1, 3, 4, 2))

for _ in range(n - 1):
    d2 = tuple(map(int, input().split()))
    for (dl, dd) in dlist:
        if d2[0] not in dd:
            cache_dice(d2)
            continue
        d0 = dd[d2[0]]
        dm = dms[d0]
        if dd[d2[1]] not in dm:
            cache_dice(d2)
            continue
        dmi = dm.index(dd[d2[1]])
        if d2[2] == d1[dm[(dmi + 1) % 4]] \
                and d2[3] == d1[dm[(dmi + 3) % 4]] \
                and d2[4] == d1[dm[(dmi + 2) % 4]] \
                and d2[5] == d1[5 - d0]:
            print('No')
            exit(0)
    cache_dice(d2)
print('Yes')

Fixed submission:
ROLL_MASTER = (
    (0, 1, 2, 3, 4, 5), (1, 0, 3, 2, 5, 4), (2, 0, 1, 4, 5, 3),
    (3, 0, 4, 1, 5, 2), (4, 0, 2, 3, 5, 1), (5, 1, 3, 2, 4, 0))
TWIST_MASTER = (0, 2, 4, 1, 3, 5)


def roll(dice, top):
    return tuple(dice[i] for i in ROLL_MASTER[top])


def twist(dice):
    return tuple(dice[i] for i in TWIST_MASTER)


def twist_check(d1, d2):
    if d1[0] != d2[0] or d1[5] != d2[5]:
        return False
    for _ in range(4):
        if d1 == d2:
            return True
        d2 = twist(d2)
    return False


def equal_check(d1, d2):
    for i in range(6):
        if twist_check(d1, roll(d2, i)):
            return True
    return False


def differs_all():
    n, d1, dset = int(input()), tuple(map(int, input().split())), set()
    dset.add(d1)

    for _ in range(n - 1):
        d2 = tuple(map(int, input().split()))
        for d1 in dset:
            if equal_check(d1, d2):
                return False
        dset.add(d2)
    return True


print('Yes' if differs_all() else 'No')
Buggy python submission (verdict: Runtime Error):
r, c = map(int, input().split())
table = [[*cc, sum(cc)] for cc in (list(map(int, input().split())) for _ in range(r))]
table.append(list(map(sum, zip(*table))))
print('\n'.join(' '.join(map(str, line)) for line in table))

Fixed submission:
r, c = map(int, input().split())
table = [cc + [sum(cc)] for cc in (list(map(int, input().split())) for _ in range(r))]
table.append(list(map(sum, zip(*table))))
for line in table:
    print(*line)

Buggy python submission (verdict: Runtime Error):
r, c = map(int, input().split())
table = [[*cc, sum(cc)] for cc in (list(map(int, input().split())) for _ in range(r))]
table.append(list(map(sum, zip(*table))))
print('\n'.join(' '.join(map(str, line)) for line in table) + '\n')

Fixed submission:
r, c = map(int, input().split())
table = [cc + [sum(cc)] for cc in (list(map(int, input().split())) for _ in range(r))]
table.append(list(map(sum, zip(*table))))
for line in table:
    print(*line)

Buggy python submission (verdict: Runtime Error):
r, c = map(int, input().split())
table = [[*cc, sum(cc)] for cc in (list(map(int, input().split())) for _ in range(r))]
table.append(list(map(sum, zip(*table))))
for line in table:
    print(*line)

Fixed submission:
r, c = map(int, input().split())
table = [cc + [sum(cc)] for cc in (list(map(int, input().split())) for _ in range(r))]
table.append(list(map(sum, zip(*table))))
for line in table:
    print(*line)
Buggy python submission (verdict: Time Limit Exceeded):
from math import sqrt, floor
from collections import deque


def prime_generator():
    prime = set()
    yield 2
    i = 3
    while True:
        for d in prime:
            if not (i % d):
                break
        else:
            yield i
            prime.add(i)
        i += 2


nstr = input()
n = int(nstr)
max = floor(sqrt(n))
a = deque()

for p in prime_generator():
    if p > n:
        break
    while not (n % p):
        n = n // p
        a.append(p)

a.appendleft(nstr + ':')
print(*a)

Fixed submission:
from math import sqrt
from collections import deque


def divide_repeat(p):
    global n, a, limit
    while not (n % p):
        a.append(p)
        n = n // p
        limit = sqrt(n)


nstr = input()
n, p = int(nstr), 3
limit = sqrt(n)
a, i = deque(), 3

divide_repeat(2)

while p <= limit:
    divide_repeat(p)
    p += 2

if n > 1:
    a.append(n)

print(nstr + ': ', end='')
print(*a)
Buggy python submission (verdict: Runtime Error):
print(pow(*map(int, input().split()), int(1e9) + 7))

Fixed submission:
m, n = map(int, input().split())
print(pow(m, n, int(1e9) + 7))
Buggy python submission (verdict: Runtime Error):
While True:
   try:
      print(len(str(sum(list(map(int,input().split()))))))
   except:
      bereak
   

Fixed submission:
while True:
   try:
      print(len(str(sum(list(map(int,input().split()))))))
   except:
      break

Buggy python submission (verdict: Runtime Error):
While True:
   try:
      print(len(str(sum(list(map(int,input().split()))))))
   except:
      break
   

Fixed submission:
while True:
   try:
      print(len(str(sum(list(map(int,input().split()))))))
   except:
      break
Buggy python submission (verdict: Runtime Error):
def count(num):    
    l1=[]
    for a in range (10):
        for b in range(10):
            for c in range (10):
                for d in range (10):
                    l1.append([a,b,c,d])
    l1=list(filter(lambda x: sum(x)==num,l1))
    return(len(l1))
while 1==1:
    print(count(int(input())))

Fixed submission:
def count(num):    
    l1=[]
    for a in range (10):
        for b in range(10):
            for c in range (10):
                for d in range (10):
                    l1.append([a,b,c,d])
    l1=list(filter(lambda x: sum(x)==num,l1))
    return(len(l1))

while True:
    try:
        print(count(int(input())))
    except:
        break

Buggy python submission (verdict: Runtime Error):
def count(num):    
    l1=[]
    for a in range (10):
        for b in range(10):
            for c in range (10):
                for d in range (10):
                    l1.append([a,b,c,d])
    l1=list(filter(lambda x: sum(x)==num,l1))
    return(len(l1))
import sys
length=len(sys.stdin.readlines())
for i in range (length):
    print(count(int(input())))

Fixed submission:
def count(num):    
    l1=[]
    for a in range (10):
        for b in range(10):
            for c in range (10):
                for d in range (10):
                    l1.append([a,b,c,d])
    l1=list(filter(lambda x: sum(x)==num,l1))
    return(len(l1))

while True:
    try:
        print(count(int(input())))
    except:
        break
Buggy python submission (verdict: Runtime Error):
num=int(input())
for i in range (num):
    info=list(map(float,input().split()))
    if info[2]==info[0]:
        if info[6]==info[4]:
            print("YES")
        else:
            print("NO")
    else:
        if (info[3]-info[1])/(info[2]-info[0])==(info[7]-info[5])/(info[6]-info[4]):
            print("YES")
        else:
            print("NO")
        

Fixed submission:
num=int(input())
for i in range (num):
    info=list(map(float,input().split()))
    info=list(map(lambda x:int(x*10**6),info))
    if info[2]==info[0]:
        if info[6]==info[4]:
            print("YES")
        else:
            print("NO")
    elif info[6]==info[4]:
        if info[2]==info[0]:
            print("YES")
        else:
            print("NO")
    else:
        if (info[3]-info[1])/(info[2]-info[0])==(info[7]-info[5])/(info[6]-info[4]):
            print("YES")
        else:
            print("NO")

Buggy python submission (verdict: Runtime Error):
num=int(input())
for i in range (num):
    info=list(map(float,input().split()))
    if info[2]==info[0]:
        if info[6]==info[4]:
            print("YES")
        else:
            print("NO")
    else:
        if (info[3]-info[1])/(info[2]-info[0])==(info[7]-info[5])/(info[6]-info[4]):
            print("YES")
        else:
            print("NO")
        

Fixed submission:
num=int(input())
for i in range (num):
    info=list(map(float,input().split()))
    info=list(map(lambda x:int(x*10**6),info))
    if info[2]==info[0]:
        if info[6]==info[4]:
            print("YES")
        else:
            print("NO")
    elif info[6]==info[4]:
        if info[2]==info[0]:
            print("YES")
        else:
            print("NO")
    else:
        if (info[3]-info[1])/(info[2]-info[0])==(info[7]-info[5])/(info[6]-info[4]):
            print("YES")
        else:
            print("NO")

Buggy python submission (verdict: Runtime Error):
num=int(input())
for i in range (num):
    info=list(map(float,input().split()))
    if info[2]==info[0]:
        if info[6]==info[4]:
            print("YES")
        else:
            print("NO")
    else:
        if (info[3]-info[1])/(info[2]-info[0])==(info[7]-info[5])/(info[6]-info[4]):
            print("YES")
        else:
            print("NO")
        

Fixed submission:
num=int(input())
for i in range (num):
    info=list(map(float,input().split()))
    info=list(map(lambda x:int(x*10**6),info))
    if info[2]==info[0]:
        if info[6]==info[4]:
            print("YES")
        else:
            print("NO")
    elif info[6]==info[4]:
        if info[2]==info[0]:
            print("YES")
        else:
            print("NO")
    else:
        if (info[3]-info[1])/(info[2]-info[0])==(info[7]-info[5])/(info[6]-info[4]):
            print("YES")
        else:
            print("NO")
Buggy python submission (verdict: Runtime Error):
print(sum(list(map(int,input().split))))

Fixed submission:
while True:
    try:
        print(sum(list(map(int,input().split()))))
    except:
        break

Buggy python submission (verdict: Runtime Error):
while True:
    print(sum(list(map(int,input().split()))))

Fixed submission:
while True:
    try:
        print(sum(list(map(int,input().split()))))
    except:
        break

Buggy python submission (verdict: Runtime Error):
while True:
    print(sum(list(map(int,input().split()))))

Fixed submission:
while True:
    try:
        print(sum(list(map(int,input().split()))))
    except:
        break

Buggy python submission (verdict: Runtime Error):
while True:
    a=input()
    if a != "":
        print(sum(list(map(int,a.split()))))
    else:
        break

Fixed submission:
while True:
    try:
        print(sum(list(map(int,input().split()))))
    except:
        break
Buggy python submission (verdict: Time Limit Exceeded):
while True:
    num=int(input())
    if num==0:
        break
    stars=input().split()
    star_list=list(set(stars))
    for i in star_list:
        if stars.count(i) > num/2:
            print(i)
            break
    else:
        print("NO COLOR")
        

Fixed submission:
while True:
    num=int(input())
    if num==0:
        break
    stars=sorted(input().split())
    if stars.count(stars[num//2]) > num/2 :
        print(stars[num//2])
    else:
        print("NO COLOR")

Buggy python submission (verdict: Time Limit Exceeded):
while True:
    num=int(input())
    if num==0:
        break
    stars=input().split()
    star_list=list(set(stars))
    for i in star_list:
        if stars.count(i) > num/2:
            print(i)
            break
    else:
        print("NO COLOR")
        

Fixed submission:
while True:
    num=int(input())
    if num==0:
        break
    stars=sorted(input().split())
    if stars.count(stars[num//2]) > num/2 :
        print(stars[num//2])
    else:
        print("NO COLOR")