qyliang/CodeNanoFix huggingface dataset:
Buggy code:
N = int(input())
edges = [[] for _ in range(N+1)]
for _ in range(N-1):
    ai, bi, ci = map(int, input().split())
    edges[ai].append((bi, ci))
    edges[bi].append((ai, ci))
Q, K = map(int, input().split())

distance = [-1]*(N+1)
# def add_weight(k, pre):
#     for v in edges[k]:
#         d, w = v
#         if d != pre:
#             distance[d] = w + distance[k]
#             add_weight(d, k)
# add_weight(K, -1)
que = deque()
que.append(edges[K]); distance[K] = 0
while len(que):
    a = que.popleft()
    for b, c in a:
        if distance[b] == -1:
            distance[b] = c
            que.append(edges[b])

for _ in range(Q):
    s, e = map(int, input().split())
    print(distance[s] + distance[e])

Fixed code:
from collections import deque

N = int(input())
edges = [[] for _ in range(N+1)]
for _ in range(N-1):
    ai, bi, ci = map(int, input().split())
    edges[ai].append((bi, ci))
    edges[bi].append((ai, ci))
Q, K = map(int, input().split())

distance = [-1]*(N+1)
# def add_weight(k, pre):
#     for v in edges[k]:
#         d, w = v
#         if d != pre:
#             distance[d] = w + distance[k]
#             add_weight(d, k)
# add_weight(K, -1)
que = deque()
que.append(K); distance[K] = 0
while len(que):
    a = que.popleft()
    for b, c in edges[a]:
        if distance[b] == -1:
            distance[b] = c + distance[a]
            que.append(b)

# print(distance)

for _ in range(Q):
    s, e = map(int, input().split())
    print(distance[s] + distance[e])
Buggy code:
#!/usr/bin/env python3

import heapq


INF = 10 ** 8


def dijkstra(num_vertices, adj_list, source=0):
    dist = [INF for _ in range(num_vertices)]
    dist[source] = 0
    pq = [(dist[u], u) for u in range(num_vertices)]
    heapq.heapify(pq)
    while pq:
        _, u = heapq.heappop(pq)
        for v, cost in adj_list[u]:
            new_length = dist[u] + cost
            if new_length < dist[v]:
                dist[v] = new_length
                heapq.heappush(pq, (new_length, v))
    return dist


def main():
    n = int(input())
    adj_list = [set() for _ in range(n)]
    for _ in range(n - 1):
        a, b, c = (int(z) for z in input().split())
        a -= 1
        b -= 1
        adj_list[a].add((b, c))
        adj_list[b].add((a, c))
    q, k = (int(z) for z in input().split())
    k -= 1
    dist = dijkstra(n, adj_list, k)
    for _ in range(q):
        x, y = (int(z) - 1 for z in input().split())
        res = dist[x] + dist[y]
        print(res)


if __name__ == '__main__':
    main()


Fixed code:
#!/usr/bin/env python3

import heapq
import sys


INF = sys.maxsize


def dijkstra(num_vertices, adj_list, source=0):
    dist = [INF for _ in range(num_vertices)]
    dist[source] = 0
    pq = [(dist[u], u) for u in range(num_vertices)]
    heapq.heapify(pq)
    while pq:
        _, u = heapq.heappop(pq)
        for v, cost in adj_list[u]:
            new_length = dist[u] + cost
            if new_length < dist[v]:
                dist[v] = new_length
                heapq.heappush(pq, (new_length, v))
    return dist


def main():
    n = int(input())
    adj_list = [set() for _ in range(n)]
    for _ in range(n - 1):
        a, b, c = (int(z) for z in input().split())
        a -= 1
        b -= 1
        adj_list[a].add((b, c))
        adj_list[b].add((a, c))
    q, k = (int(z) for z in input().split())
    k -= 1
    dist = dijkstra(n, adj_list, k)
    for _ in range(q):
        x, y = (int(z) - 1 for z in input().split())
        res = dist[x] + dist[y]
        print(res)


if __name__ == '__main__':
    main()
Buggy code:
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

n = ni()
g = []
for i in range(n+1): g.append([])

for i in range(n-1):
    a, b, c = na()
    g[a].append((b,c))
    g[b].append((a,c))

q,k = na()

def dfs(cur, pre, g, par, dw, w):
    dw[cur] = w
    par[cur] = pre
    for e in g[cur]:
        if e[0] != pre:
            dfs(e[0], cur, g, par, dw, w + e[1])

par = [-1] * (n+2)
dw = [-1] * (n+2)
from asyncio import Queue
qs = Queue()
qs.put(k)
dw[k] = 0

while not qs.empty():
    cur = qs.get()
    for e in g[cur]:
        if e[0] != par[cur]:
            par[e[0]] = cur
            dw[e[0]] = dw[cur] + e[1]
            qs.put(e[0])


# dfs(k, -1, g, par, dw, 0)

for z in range(q):
    x, y = na()
    print(dw[x] + dw[y])



Fixed code:
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

n = ni()
g = []
for i in range(n+1): g.append([])

for i in range(n-1):
    a, b, c = na()
    g[a].append((b,c))
    g[b].append((a,c))

q,k = na()

def dfs(cur, pre, g, par, dw, w):
    dw[cur] = w
    par[cur] = pre
    for e in g[cur]:
        if e[0] != pre:
            dfs(e[0], cur, g, par, dw, w + e[1])

par = [-1] * (n+2)
dw = [-1] * (n+2)
from queue import Queue
qs = Queue()
qs.put(k)
dw[k] = 0

while not qs.empty():
    cur = qs.get()
    for e in g[cur]:
        if e[0] != par[cur]:
            par[e[0]] = cur
            dw[e[0]] = dw[cur] + e[1]
            qs.put(e[0])


# dfs(k, -1, g, par, dw, 0)

for z in range(q):
    x, y = na()
    print(dw[x] + dw[y])
Buggy code:
# AtCoder
A, B = map(int, input().split())
if A % 3 == 0 or B % 3 == 0 or A*B % 3 == 0:
    print('Possible')
else:
    print('Impossible')


Fixed code:
# AtCoder
A, B = map(int, input().split())
if A % 3 == 0 or B % 3 == 0 or (A+B) % 3 == 0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
A, B = map(int, input().split())

if A + B % 3 == 0 or A % 3 == 0 or B % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Fixed code:
A, B = map(int, input().split())

if (A + B) % 3 == 0 or A % 3 == 0 or B % 3 == 0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a, b = map(int, input().split())
if a % 3 == 0 or b % 3 == 0 or (a+b) % 3 == 0:
  print("Possible")
else:
  Print("Impossible")

Fixed code:
a,b=map(int,input().split())
if (a%3==0) or (b%3==0) or ((a+b)%3==0):
  print("Possible")
else:
  print("Impossible")
Buggy code:
a,b=map(int, input().split()) 
if (a+b)%3 ==0 or a%==0 or b%==0:
    print("Possible")
else:
    print("Impossible")

Fixed code:
a,b = map(int,input().split())
if a % 3==0 or b%3==0 or (a+b)%3==0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
def Q1(x):
    A, B = x[0], x[1]
    if (A + B) % 3 == 0:
        return 'Possible'
    else:
        return 'Imossible'

l = [int(i) for i in input().split()]
print(Q1(l))

Fixed code:
def Q1(x):
    A, B = x[0], x[1]
    if A % 3 == 0 or B % 3 == 0 or (A + B) % 3 == 0:
        return 'Possible'
    else:
        return 'Impossible'

l = [int(i) for i in input().split()]
print(Q1(l))
Buggy code:
a,b=map(int,input().split())
if a%3==0 or b%3==0 or a+b%3==0:
  print('Possible')
else:print('Impossible')

Fixed code:
a,s=map(int,input().split())
if a%3==0 or s%3==0 or (a+s)%3==0:
  print("Possible")
else:
  print("Impossible")
Buggy code:
a, b, c = map(int, input().split())

if a % 3 == 0 or b % 3 == 0 or (a + b) % 3 ==0:
  print("Possible")
else:
  print("Impossible")

Fixed code:
a,b = map(int, input().split())

if a%3==0 or b%3==0 or (a+b)%3==0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
A,B =map(int,input().split())
if A%3 == o or B%3 ==0 or (A+B)%3 ==0:
  print("Possible")
  
else:
  print("Impossible")

Fixed code:
A,B =map(int,input().split())
if A%3 == 0 or B%3 ==0 or (A+B)%3 ==0:
  print("Possible")
  
else:
  print("Impossible")
Buggy code:
a, b = map(int, raw_input().split())


if a % 3 == 0 or b % 3 == 0 or (a+b)%3==0:
    print("Possible")
else:
    print("Impossible")



Fixed code:
a, b = map(int, input().split())
if a % 3 == 0 or b % 3 == 0 or (a+b) % 3 == 0:
  print('Possible')
else:
  print('Impossible')
Buggy code:
a,b =map(int,input().split())
k = a%3
s = b%3
if k ==s and k != 0:
  print("Impossible)
else:
  print("Possible")

Fixed code:
a,b =map(int,input().split())
k = a%3
s = b%3
if k == s and k != 0:
  print("Impossible")
else:
  print("Possible")
Buggy code:
a, b = map(int, input().split())
if a + b % 3 == 0 or a % 3 == 0 or b % 3 == 0:
    print('Possible')
else:
    print('Impossible')   

Fixed code:
a, b = map(int, input().split())
if (a % 3) * (b % 3) * ((a+b) % 3) == 0:
  print("Possible")
else:
  print("Impossible")
Buggy code:
a,b=map(int,input().split())
if (a+b)%3!=0 and a%3!=0 and b%3!=0:
  print("Possible")
elif a!=0 and b!=0:
  print("Impossible")
else:
  print("Impossible")
      


Fixed code:
a,b = map(int,input().split())
if (a+b) % 3 == 0:
  print('Possible')
elif a % 3 == 0:
  print('Possible')
elif b % 3 == 0:
  print('Possible')
else:
  print('Impossible')
Buggy code:
a,b=map(int,input().split())
if (a+b)%3==0 or a%3==0 or b%3==0:
  print("Possible")
else:
  print("Inpossible")


Fixed code:
a,b = map(int,input().split())

if a%3 == 0 or b%3 == 0 or (a+b)%3 == 0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
a,b=map(int,input().split())
if (a+b)%3!=0 and a%3!=0 and b%3!=0:
  print("Possible")
elif a!=0 and b!=0:
  print("Inpossible")
else:
  print("Inpossible")
      


Fixed code:
a,b=map(int,input().split())
if (a+b)%3!=0 and a%3!=0 and b%3!=0:
  print("Impossible")
elif a!=0 and b!=0:
  print("Possible")
else:
  print("Possible")
Buggy code:
a,b = map(int,input().split())
orint("Possible" if a%3==0 or b%3==0 or (a+b)%3==0 else "Impossible")

Fixed code:
a, b = map(int, input().split())

print("Possible" if (a+b)%3 == 0 or (a)%3 == 0 or (b)%3==0 else "Impossible")
Buggy code:
a,b = map(int,input().split())

if a % 3 == 0 or b % 3 == 0 or (a + b) % 3 == 0:
    print('Possible')
else:
    print('Imposibble')

Fixed code:
a, b = map(int, input().split())

if a%3==0 or b%3==0 or (a+b)%3==0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a, b = [int(x) for x in input().split()]
if (a + b) % 3 or a % 3 or b % 3:
    print('Possible ')
else:
    print('Impossible')

Fixed code:
a, b = [int(x) for x in input().split()]
if (a + b) % 3 == 0 or a % 3 == 0 or b % 3 == 0:
    print('Possible ')
else:
    print('Impossible')
Buggy code:
A,B = map(int,input().split())
if A % 3 == 0 or B % 3 == 0 or (A + B) % 3 == 0:
  print("Possible")
else:
  print("Inpossible")

Fixed code:
A,B = map(int,input().split())

if (A+B)%3==0 or A%3==0 or B%3==0:
    print("Possible")

else:
    print("Impossible")
Buggy code:
a, b = map(int, input().split())

if a % 3 == 0 or b % 3 == 0 or a + b % 3 == 0:
  print('Possible')
else:
  print('Impossible')

Fixed code:
a, b = list(map(int, input().split()))

if a % 3 == 0 or b % 3 == 0 or (a + b) % 3 == 0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
A, B = map(int, input().split())

if A % 3 == 0 or B % 3 == 0 or A + B % == 0:
    print('Possible')
else:
    print('Impossible')

Fixed code:
#ABC067A
A, B = map(int, input().split())
if A%3 == 0 or B%3 == 0 or (A+B)%3 == 0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a, b = input().split(' ')
c = int(a) + int(b)
if a%3==0 or b%3==0 or c%3==0:
  print("Possible")
else:
  print("Impossible")

Fixed code:
a, b = map(int, input().split(" "))
if a % 3 == 0 or b % 3 == 0 or (a + b) % 3 == 0:
  print("Possible")
else:
  print("Impossible")
Buggy code:
A,B=map(int,input().split())
if A%3==0 or B%3==0 or A+B%3==0:
  print("Possible")
else:
  print("Impossible")

Fixed code:
# A
A, B = list(map(int, input().split()))

if A % 3 == 0 or B % 3 == 0 or (A + B) % 3 ==0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a,b=map(int, input().split())
if a%3 == 0 or b%3 == 0 or sum(a,b)%3== 0:
  print("Possible")
else:
  print("Impossible")

Fixed code:
a, b = map(int, input().split(' '))

if a % 3 == 0 or b % 3 == 0 or (a+b) % 3 == 0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
import sys
input = sys.stdin.readline

a,b=map(int,input().split())
if a%3==0 or b%3--0 or (a+b)%3==0:
    print("Possible")
else:
    print("Impossible")


Fixed code:
import sys
input = sys.stdin.readline

a,b=map(int,input().split())
if a%3==0 or b%3==0 or (a+b)%3==0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a,b=map(int,input().split())
print("Possible" if a%3==0 or b%3==0 or a+b%3==0 else "Impossible")

Fixed code:
a,b = map(int,input().split())
print("Possible" if a % 3 == 0 or b % 3 == 0 or (a+b) % 3 == 0 else "Impossible")
Buggy code:
A,B = map(int,input().split())
if A%3==0 or B%3==0 or (A+B)%==0:
  print('Possible')
else:
  print('Impossible')

Fixed code:
A,B=map(int,input().split())
if A%3==0 or B%3==0 or(A+B)%3==0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
A,B=map(int,input().split())
print('Possible') if A%3==0or B%3==0or(A+B)%3==0 else print('Impossible')

Fixed code:
A, B = map(int, input().split())

print("Possible" if A % 3 == 0 or B % 3 == 0 or (A + B) % 3 == 0 else "Impossible")
Buggy code:
A, B = map(int, raw_input().split())
if A + B % 3 == 0:
    print "Possible"
elif A % 3 == 0:
    print "Possible"
elif B % 3 == 0:
    print "Possible"
else:
    print "Impossible"


Fixed code:
A,B=map(int,input().split())
if A%3==0:
    print("Possible")
elif B%3==0:
    print("Possible")
elif (A+B)%3==0:
    print("Possible")
else :
    print("Impossible")
Buggy code:
# -*- coding: utf-8 -*-
import sys

A, B = map(int, input().split())

C = A + B

if A%3 == 0:
    print('Possible')
else if B%3 == 0:
    print('Possible')
else if C%3 == 0:
    print('Possible')
else:
    print('Impossible')

Fixed code:
# -*- coding: utf-8 -*-
import sys

A, B = map(int, input().split())

C = A + B

if A%3 == 0:
    print('Possible')
elif B%3 == 0:
    print('Possible')
elif C%3 == 0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
A,B=input().split(" ")
print("Impossible" if A*B*(A+B)%3 else "Possible")

Fixed code:
A,B=map(int,input().split(" "))
print("Impossible" if A*B*(A+B)%3 else "Possible")
Buggy code:
a, b = list(map(int, input().split()))
if(a % 3 == 0 or b % 3 ==0 or (a + b)4 5 % 3 == 0):
    print("Possible")
else:
    print("Impossible")


Fixed code:
a, b = list(map(int, input().split()))
if(a % 3 == 0 or b % 3 ==0 or (a + b) % 3 == 0):
    print("Possible")
else:
    print("Impossible")
Buggy code:
a, b = map(int, input().split(" "))
if a % 3 == 0 or b % 3 == 0 or a + b % 3 == 0:
  print("Possible")
else:
  print("Impossible")

Fixed code:
a,b = map(int, input().split())
if (a) % 3 == 0 or b%3==0 or(a+b)%3==0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a,b=map(int,input().split())
print('Possible' if (a%3==0 or b%3==0 or a+b%3==0) else 'Impossible')

Fixed code:
a, b = map(int, input().split())

if a % 3 == 0 or b % 3 == 0:
    print('Possible')
elif (a + b) % 3 == 0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
a,b=map(int,input().split())
print('Possible' if a%3 or b%3 or (a+b)%3 else 'Impossible')

Fixed code:
a, b = map(int, input().split())
print('Possible' if ((a % 3) == 0 or (b % 3) == 0 or ((a + b) % 3) == 0) else 'Impossible')
Buggy code:
A, B = map(int, input().split())
if A % 3 == 0 or B % 3 == 0 or (A + B) == 0:
  print('Possible')
else:
  print('Impossible')

Fixed code:
A,B = map(int,input().split())
if A % 3 == 0 or B % 3==0 or (A+B)%3 == 0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()


def main():
    a,b = I()
    if min(a % 3, b%3, (a+b)%3) == 0:
        return 'Possible'

    return 'Impossible'


print(main())





Fixed code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()


def main():
    a,b = LI()
    if min(a % 3, b%3, (a+b)%3) == 0:
        return 'Possible'

    return 'Impossible'


print(main())
Buggy code:
a,b=(iny(x) for x in input().split())

if a%3==0 or b%3==0 or a+b%3==0:
    print("Possible")
else:
    print("Impossible")

    

Fixed code:
a,b=(int(x) for x in input().split())

if a%3==0 or b%3==0 or (a+b)%3==0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
A, B = map(int, input().split())

if A % 3 == 0 or B % 3 == 0 or (A+B) & 3 == 0:
    print("Possible")
else:
    print("Impossible")


Fixed code:
A, B = map(int, input().split())

if A % 3 == 0 or B % 3 == 0 or (A+B) % 3 == 0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a, b = map(int, input().split(" "))

if (a%3 ==0) or (b%3 ==0) or ((a+b)%3 ==0)):
    print("Possible")
else:
    print("Impossible")

Fixed code:
a, b = map(int, input().split(" "))
 
if (a%3 ==0) or (b%3 ==0) or ((a+b)%3 ==0):
    print("Possible")
else:
    print("Impossible")
Buggy code:
a, b = input().split(" ")

if (a+b) %3 == 0:
    print("Possible")
elif a%3 == 0:
    print("Possible")
elif b%3 == 0:
    print("Possible")
else:
    print("Impossible")


Fixed code:
a, b = map(int, input().split(" "))

if (a+b)%3 == 0:
    print("Possible")
elif a%3 == 0:
    print("Possible")
elif b%3 == 0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a, b = map(int, input().split())
if a%3 or b%3 or (a+b)%3: print("Possible")
else: print("Impossible")

Fixed code:
a, b = map(int, input().split())
if a%3 and b%3 and (a+b)%3: print("Impossible")
else: print("Possible")
Buggy code:
A,B = map(int, input().split())

if (A % 3 == 0) or\
    (B % 3 == 0) or\
    (A+B % 3 == 0):
        print("Possible")
else:
    print("Impossible")

Fixed code:
A, B =list(map(int, input().split()))
if A % 3 == 0 or B % 3 == 0 or (A + B) % 3 == 0:
	print("Possible")
else:
	print("Impossible")
Buggy code:
a,b = map(int, input().split())

if a/3 == 0 or b/3 == 0 or (a+b)/3 == 0:
  print("Possible")
else :
  print("Impossible")


Fixed code:
a,b=map(int,input().split())

if a%3==0 or b%3==0 or (a+b)%3==0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a,b = map(int,input().split())
print("Possible" if a % 3 == 0 or b % 3 == 0 or a+b % 3 == 0 else "Impossible")


Fixed code:
a,b =map(int,input().split())
a%=3
b%=3
print("Possible" if not a or not b or not (a+b)%3 else "Impossible")
Buggy code:
a,b = map(int, input().split())
if a%3 == 0 or b%3 == 0 or a+b%3 == 0:
    print("Possible")
else:
    print("Impossible")

Fixed code:
a,b=map(int,input().split())
c=a + b
 
if  a%3==0 or b%3==0 or c%3==0: print("Possible")
else: print("Impossible")
Buggy code:
a,b = [int(x) for x in split().input()]
if a%3==0 or b%3==0 or (a+b)%3==0:
  print("Possible")
else:
  print("Impossible")

Fixed code:
a,b = [int(x) for x in input().split()]
if a%3==0 or b%3==0 or (a+b)%3==0:
  print("Possible")
else:
  print("Impossible")
Buggy code:
a,b=map(int,input())
if a%3==0 or b%3==0 or (a+b)%3==0:
 print("Possible")
else:
 print("Impossible")

Fixed code:
a,b=map(int, input().split())
if a%3==0 or b%3==0 or (a+b)%3==0:
  print("Possible")
else:
  print("Impossible")
Buggy code:
a, b = map(int, input().split())
if a%3==0 or b%3==0 or (a+b)%3==0:
    print('possible')
else:
    print('Impossible')

Fixed code:
a,b=map(int,input().split())
if(a%3==0 or b%3==0 or(a+b)%3==0):
  print("Possible")
else:
  print("Impossible")
Buggy code:
a = list(map(int,input().split()))
A = a[0]
B = a[1]

if (A+B)%3==0 or A%3==0 or B%3==0:
    print('Possible')
else:
    print('impossible')


Fixed code:
a = list(map(int,input().split()))
A = a[0]
B = a[1]

if (A+B)%3==0 or A%3==0 or B%3==0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
A, B = map(int, input().split())

if A % 3 == 0 or B % 3 == 0 or (A + B) % 3 == 0:
  print('Possoble')
else:
  print('Impossible')

Fixed code:
A,B = map(int,input().split())
if A % 3 == 0 or B % 3 == 0 or (A+B) % 3 == 0:
    print('Possible')
else:
    print('Impossible')
Buggy code:
a,b=[int(x) for x in input().split()]
if (a%3==1 and b%3==1) or (a%3==2 and b%3==2):
  print('Possible')
else:
  print('Impposible')

Fixed code:
a,b=[int(x) for x in input().split()]
if (a%3==1 and b%3==1) or (a%3==2 and b%3==2):
  print('Impossible')
else:
  print('Possible')
Buggy code:
a = list(map(int(), input().split()))
if a[0]%3==0 or a[1]%3==0 or (a[0]+a[1])%3==0:
  print(Possible)
else:
  print(Impossible)

Fixed code:
a = list(map(int, input().split()))
if a[0]%3==0 or a[1]%3==0 or (a[0]+a[1])%3==0:
  print('Possible')
else:
  print('Impossible')
Buggy code:
a, b = map(int, input())
print("Possible" if (a+b)%3==0 or a%3==0 or b%3==0 else "Impossible")

Fixed code:
a, b = map(int, input().split())
print("Possible" if (a+b)%3==0 or a%3==0 or b%3==0 else "Impossible")
Buggy code:
A,B = map(int,input().rstrip().split(" "))
if(A % 3 == 0 or B % 3 == 0 or (A + B) % 3 == 0):
    print("Possible")
else:
    print("Imossible")

Fixed code:
A,B = map(int,input().rstrip().split(" "))
if(A % 3 == 0 or B % 3 == 0 or (A + B) % 3 == 0):
    print("Possible")
else:
    print("Impossible")
Buggy code:
a,b=map(int,input().split())
if a%3!=0 and b%3!=0 and (a+b)%3!=0:
  print('Impossible')
else:
  print('Posible')

Fixed code:
a,b=map(int,input().split())
if a%3!=0 and b%3!=0 and (a+b)%3!=0:
  print('Impossible')
else:
  print('Possible')
Buggy code:
a,b=map(int,input().split())print(('P','Imp')[a*b*(a+b)%3>0]+'ossible')

Fixed code:
a,b=map(int,input().split());print(['P','Imp'][a*b*(a+b)%3>0]+'ossible')
Buggy code:
a,b=map(int,input().split())
print("Possible" if any(a%3==0,b%3==0,(a+b)%3==0) else "Impossible")

Fixed code:
a,b=map(int,input().split())
print("Possible" if any([a%3==0,b%3==0,(a+b)%3==0]) else "Impossible")
Buggy code:
a,b=map(int,input().split());print('Possible' if a%3==0 else 'Possible' if b%3==0 else 'Possible' a+b%3==0 else 'Impossible')

Fixed code:
a,b=map(int,input().split());print('Possible' if a%3==0 else 'Possible' if b%3==0 else 'Possible' if (a+b)%3==0 else 'Impossible')
Buggy code:
a,b = map(int,input().split())
	if a % 3 == 0 or b % 3 == 0 or (a+b) % 3 == 0:
    	print('Possible')
    else:
        print('Impossible')

Fixed code:
a , b = map(int,input().split())
if a%3 == 0 or b%3 == 0 or (a+b)%3 == 0:
 print("Possible")
else:
 print("Impossible")
Buggy code:
a = input().split(' ')
b = list(map((int), a))
sum = sum(b)
A = sum[0]
B = sum[1]

if sum % 3 == 0 || A % 3 == 0 || B % 3 == 0:
    print('Possible')

else:
    print('Impossible')


Fixed code:
a = input().split(' ')
b = list(map((int), a))
sum = sum(b)
A = b[0]
B = b[1]

if sum % 3 == 0 or A % 3 == 0 or B % 3 == 0:
    print('Possible')

else:
    print('Impossible')
Buggy code:
#!/usr/bin/env python3
a,b = map(int,input().split())
if (a % 3)*(b % 3) % 3 == 1:
    print("Possible")
else:
    print("Impossible")

Fixed code:
#!/usr/bin/env python3
a,b = map(int,input().split())
if (a % 3)*(b % 3) % 3 != 1:
    print("Possible")
else:
    print("Impossible")
Buggy code:
A,B = [int(i) for i in input().split()]
if A % 3 == 0:
    print("Possible")
elif B % 3 == 0:
    print("Possible")
elif (A + B) % 3 == 0:
    print("Possible")
else:
    print("ImPossible")

Fixed code:
A,B = [int(i) for i in input().split()]
if A % 3 == 0:
    print("Possible")
elif B % 3 == 0:
    print("Possible")
elif (A + B) % 3 == 0:
    print("Possible")
else:
    print("Impossible")
Buggy code:
a,b = map(int,input())

if a%3 == 0 or b%3 == 0 or (a+b)%3 == 0:
  print("Possible")
else:
  print("Impossible")

Fixed code:
a,b=map(int,input().split())

if a%3==0 or b%3==0 or (a+b)%3==0:
  print("Possible")
else:
  print("Impossible")