qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a, b = map(int, input().split())

if a < b:
  print(a)
else:
  print(a-1)


Fixed code:
a, b = list(map(int, input().split()))
if a <= b:
  print(a)
else:
  print(a - 1)
Buggy code:
t,h=map(int,input().split())
a=13-t
if h>t:
	a=a-1
print(a)

Fixed code:
t,h=map(int,input().split())
a=t
if t>h:
	a=a-1
print(a)
Buggy code:
 a,b = list(map(int,input().split()))     
 if a > b:                                
     print(a - 1)                         
 else:                                    
     print(a)c:w                          


Fixed code:
a,b = list(map(int,input().split())) 
if a > b:                            
    print(a - 1)                     
else:                                
    print(a)
Buggy code:
a,b = map(int,input().split())
print( (a-1) if a>b else (a+1))

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

print(a if b >= a else a - 1)
Buggy code:
i = list(map(int, input().split()))
a = i[0]
b = i[1]

if b > a:
  print(a)
else:
  print(a - 1)

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

if b >= a:
  print(a)
else:
  print(a - 1)
Buggy code:
Tmp = []
Tmp = input().rstrip().split(' ')

M = int(Tmp[0])
N = int(Tmp[1])

if M=<N:
    print(N)
else:
    print(N-1)


Fixed code:
Tmp = []
Tmp = input().rstrip().split(' ')
 
M = int(Tmp[0])
N = int(Tmp[1])
 
if M<=N:
    print(M)
else:
    print(M-1)
Buggy code:
a, b = map(int, input().split())
if a >= b:
    print(a)
else:
    print(a-1)


Fixed code:
a,b = map(int, input().split())
if b >= a :
	print(a)
else :
	print(a-1)
Buggy code:
num = input().split()

if int(num[1]) >=11:
  print(num[0])
else:
  print(int(num[0])-1)

Fixed code:
num = input().split()

if int(num[1]) >= int(num[0]):
  print(num[0])
else:
  print(int(num[0])-1)
Buggy code:
a,b = map(int, input().split())
if a < b:
  print(a)
else:
  print(a-1)

Fixed code:
a,b = map(int,input().split(" "))
if a <= b:
	print(a)
else:
	print(a-1)
Buggy code:
a, b = (int(i) for i in input().split())
ans = a
if a > b: a -= 1
print(ans)

Fixed code:
a, b = (int(i) for i in input().split())
ans = a
if a > b: ans -= 1
print(ans)
Buggy code:
b, c = map(int, input().split())
if(c > b):
  print(b)
else:
  print(b-1)

Fixed code:
b, c = map(int, input().split())
if(c >= b):
  print(b)
else:
  print(b-1)
Buggy code:
a,b = map(int,input().split())
print(b if a <= b else b-1)

Fixed code:
a,b = map(int,input().split())
if a<=b :print(a)
else:print(a-1)
Buggy code:
a,b=map(int,input().split())
print(a-(a<b))

Fixed code:
a,b=map(int,input().split())
print(str(a-(b<a)))
Buggy code:
a,b=map(int, input().split())
if a<b:
  print(a)
else:
  print(a-1)


Fixed code:
a,b=map(int,input().split())
if a<b:
    print (a)
elif a==b:
    print (a)
else:
    print (a-1)
Buggy code:

a,b=map(int,input().split())
cnt = 0
cnt += a
if a < b:
    cnt -= 1
print(cnt)

Fixed code:

a,b=map(int,input().split())
cnt = 0
cnt += a
if b < a:
    cnt -= 1
print(cnt)
Buggy code:
A,B=map(int,input().split())

if A>=B:
  print(A-1)
else:
  print(A)

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

if B>=A:
  print(A)
else:
  print(A-1)
Buggy code:
a, b = [int(i) for i in input().spili()]

print(a if a <= b else a - 1)

Fixed code:
a, b = [int(i) for i in input().split()]
print(a if a <= b else a-1)
Buggy code:
a, b = (map(int, input().split()))
if (a <= b):
    print(a)
else:
    print(a-1

Fixed code:
a, b = map(int, input().split())
if (a <= b):
    print(a)
else:
    print(a-1)
Buggy code:
a, b = map(int, input().split())

if a>= b:
  print(a - 1)
else:
  print(a)

Fixed code:
a, b = map(int, input().split())
if a > b:
    print(a-1)
else:
    print(a)
Buggy code:
x, y = map(int, input().split())
ans = x - 1
if x <= y: 
    ans++
print(ans)

Fixed code:
x, y = map(int, input().split())
ans = x - 1
if x <= y: 
    ans = ans + 1
print(ans)
Buggy code:
a,b = map(int,input().split())
if a>b:
  a -1
else:
  a

Fixed code:
a,b=map(int,input().split())
if a > b:
  print(a-1)
else:
  print(a)
Buggy code:
import sys, re
from math import ceil, floor, sqrt, pi, factorial#, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline 
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7

def main():
    a, b = i_map()

    if a == b:
        a += 1

    print(a)

if __name__ == '__main__':
    main()


Fixed code:
import sys, re
from math import ceil, floor, sqrt, pi, factorial#, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline 
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7

def main():
    a, b = i_map()

    if a > b:
        a-= 1

    print(a)

if __name__ == '__main__':
    main()
Buggy code:
a, b = map(int, input().split())
print(a - (0 if a < b else 1))

Fixed code:
a, b = map(int, input().split())
print(a - (0 if a <= b else 1))
Buggy code:
a, b = map(int, input().split())

if b > a:
  print(a-1)
else:
  print(a)

Fixed code:
a, b = map(int, input().split())
if(b >= a):
    print(a)
else:
    print(a - 1)
Buggy code:
a,b = map(int,input().split())

if b => a:
  print(a)
else:
  print(a-1)

Fixed code:
a, b = map(int, input().split())
print(a - 1) if a > b else print(a)
Buggy code:
a,b = map(int,input().split())

if b <= a:
  print(a)
else:
  print(a-1)

Fixed code:
a,b = map(int,input().split())
if(a <= b):
    print(a)
else:
    print(a-1)
Buggy code:
a,b = map(int, input().split())
count=0


if a < b:
    count=a
else:
    count=a-1
    
print(count)

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


if a <= b:
    count=a
else:
    count=a-1
    
print(count)
Buggy code:
a,b=map(int,input().split())

print(a if a<=b else: a-1)
  

Fixed code:
a, b =  map(int,input().split())
if a <= b:
    print(a)
else:
    print(a-1)
Buggy code:
a,b = [int(i) for i in input().split()]
if a<b:
    print(a)
else:
    print(a-1)

Fixed code:
a,b = [int(i) for i in input().split()]
if a<=b:
    print(a)
else:
    print(a-1)
Buggy code:
a,b = map(int,input().split())
if a >= b:
  print(a-1)
else:
  print(a)

Fixed code:
a,b = map(int,input().split())
print(a if b>=a else (a-1))
Buggy code:
a,b = map(int,input().split())
if b > a:
    print(a)
else:
    print(a-1)

Fixed code:
a,b = map(int,input().split())
if a > b: a -= 1
print(a)
Buggy code:
a, b = map(int, input().split())
if a<b:
  print(a)
else:
  print(a-1)

Fixed code:
a,b = map (int,input ().split ())
print (a if a<=b else a-1)
Buggy code:
a, b = map(int, input().split())

print(a-1 + b >= a)

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

print(a-1 + int(b >= a))
Buggy code:
a,b=map(int,input().split())
if a < b:print(a+1)
else:print(a)

Fixed code:
a,b= map(int,input().split())
if a < b+1 :print(a)
else :print(a-1)
Buggy code:
a , b = input().split()
a = int(a)
b = int(b)
print(a,b)
if b > a:
    print(a)
else:
    print(a-1)

Fixed code:
a , b = input().split()
a = int(a)
b = int(b)
if b >= a:
    print(a)
else:
    print(a-1)
Buggy code:
a,b = input().split()

int a
int b

if a<=b:
  print(a)
else:
  print(a-1)

Fixed code:
a,b = map(int, input().split())
if a<=b :
    print(a)
else :
    print(a-1)
Buggy code:
a, b = map(int, input().split())
print(a if a<b else a-1)

Fixed code:
a,b=map(int,input().split())
print(a if a <= b else a-1)
Buggy code:


def main():
	line = input()
	vector = [int(x) for x in line.split()]
	a = vector[0]
	b = vector[1]
	if a >= b:
		print(a)
	else:
		print(a - 1)



if __name__ == "__main__":
	main()

Fixed code:

def main():
	line = input()
	vector = [int(x) for x in line.split()]
	a = vector[0]
	b = vector[1]
	if a <= b:
		print(a)
	else:
		print(a - 1)
 
 
 
if __name__ == "__main__":
	main()
Buggy code:
a,b = map(int,input().split())
if a>=b:
    print(a-1)
else:
    print(a)

Fixed code:
a,b=map(int,input().split())
if (b>=a):
    print(a)
else:
    print(a-1)
Buggy code:
LI = lambda: list(map(int, input().split()))

a, b = LI()


def main():
    ans = a - 1 if a < b else a
    print(ans)


if __name__ == "__main__":
    main()


Fixed code:
LI = lambda: list(map(int, input().split()))

a, b = LI()


def main():
    ans = a - 1 if b < a else a
    print(ans)


if __name__ == "__main__":
    main()
Buggy code:
a,b = map(int,input().split())
print(a - b < a)

Fixed code:
a,b = map(int,input().split())
print(a - (b < a))
Buggy code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b = INTM()
    if a<b:
        print(1-a)
    else:
        print(a)
if __name__ == '__main__':
    do()

Fixed code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b = INTM()
    if a>b:
        print(a-1)
    else:
        print(a)
if __name__ == '__main__':
    do()
Buggy code:
a,b=map(int,input().split())
print(a if b>a else a-1)

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

if b >=a:
    print(a)
else :
    print(a-1)
Buggy code:
a, b = map(int, input().split())

if a < b:
  print(a-1)
else:
  print(a)

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

if a == b:
    print(a)
elif a < b:
    print(a)
else:
    print(a-1)
Buggy code:
m,d = map(int,input().split(" "))
print(m if m >= d else m-1)

Fixed code:
m,d = map(int,input().split(" "))
print(m if d >= m else m-1)
Buggy code:
a, b = map(int, input().rstrip().split())
print(a if a < b else a-1)

Fixed code:
a, b = map(int, input().rstrip().split())
print(a if a <= b else a-1)
Buggy code:
def main():
    a,b = map(int, input().split())
    if a<b:
        print(a)
    else:
        print(a-1)

if __name__ == "__main__":
    main()


Fixed code:
def main():
    a,b = map(int, input().split())
    if a<=b:
        print(a)
    else:
        print(a-1)

if __name__ == "__main__":
    main()
Buggy code:
a, b = map(int, input().split())

if b <= a:
    ans = a - 1
else:
    ans = a

print(ans)

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

if b < a:
    ans = a - 1
else:
    ans = a

print(ans)
Buggy code:
a, b = (int(i) for i in input().split())

if b <= a:
    ans = a - 1
else:
    ans = a

print(a)

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

if b < a:
    ans = a - 1
else:
    ans = a

print(ans)
Buggy code:
a, b = map(int, input().split())
cnt = a-1
if a == b:
    cnt += 1
print(cnt)

Fixed code:
a, b = map(int, input().split())
cnt = a-1
if a <= b:
    cnt += 1
print(cnt)
Buggy code:
a,b=map(int,input().split)
print(a-b if b<a else a-b+1)

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

print(a if a <= b else a-1)
Buggy code:
a,b = map(int,input().split())
if a > b :
    print(b)
else:
    print(a-1)

Fixed code:
a,b = map(int,input().split())
if b >= a :
    print(a)
else:
    print(a-1)
Buggy code:
a,b=map(int,input().split)
print(a if a<=b else a-1)

Fixed code:
a, b = map(int, input().split())
if a <= b :
    print(a)
else:
    print(a-1)
Buggy code:
import math
import itertools
from heapq import heapify, heappop, heappush
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect, bisect_left, bisect_right
from collections import defaultdict, deque


# d = defaultdict(lambda: 0)
# setrecursionlimit(10**7)
# inf = float("inf")


##### stdin ####
def LM(t, r): return list(map(t, r))
def R(): return stdin.readline()
def RS(): return R().split()
def I(): return int(R())
def F(): return float(R())
def LI(): return LM(int,RS())
def LF(): return LM(float,RS())
def ONE_SL(): return list(input())
def ONE_IL(): return LM(int, ONE_SL())
def ALL_IL(): return LM(int,stdin)

##### tools #####
def ap(f): return f.append
def pll(li): print('\n'.join(LM(str,li)))
def pljoin(li, s): print(s.join(li))



##### main #####
def main():
	m,d = LI()
	print(m-1 if m >= d  else m)

if __name__ == '__main__':
  main()

Fixed code:
import math
import itertools
from heapq import heapify, heappop, heappush
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect, bisect_left, bisect_right
from collections import defaultdict, deque


# d = defaultdict(lambda: 0)
# setrecursionlimit(10**7)
# inf = float("inf")


##### stdin ####
def LM(t, r): return list(map(t, r))
def R(): return stdin.readline()
def RS(): return R().split()
def I(): return int(R())
def F(): return float(R())
def LI(): return LM(int,RS())
def LF(): return LM(float,RS())
def ONE_SL(): return list(input())
def ONE_IL(): return LM(int, ONE_SL())
def ALL_IL(): return LM(int,stdin)

##### tools #####
def ap(f): return f.append
def pll(li): print('\n'.join(LM(str,li)))
def pljoin(li, s): print(s.join(li))



##### main #####
def main():
	m,d = LI()
	print(m if m <= d  else m-1)

if __name__ == '__main__':
  main()
Buggy code:
# n objects m seller 
# Write your code here
import math
a,b=map(int,input().split());
ans=a;
if a>b : 
    ans--;
print(ans);

Fixed code:
# n objects m seller 
# Write your code here
import math
a,b=map(int,input().split());
ans=a;
if a>b : 
    ans=ans-1;
print(ans);
Buggy code:
a,b=map(int,input().split())
print(a if(a<b) else print(a-1))

Fixed code:
a,b=map(int,input().split())
print(a if (a<=b) else a-1)
Buggy code:
a, b = map( int, input().split())

if( b <= a):
  count = a - 1
    
else:
  count = a
    
print(count)

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

if( b < a):
  count = a - 1
    
else:
  count = a
    
print(count)
Buggy code:
y, m = map(int, input().split())
print(y + (1 if y <= m else 0))

Fixed code:
y, m = map(int, input().split())
print(y - 1 + (1 if y <= m else 0))
Buggy code:
a,b= map(int,input().split())
if b>a:
    print(a)
else:
    print(a-1)

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

if a > b:
    print(a - 1)
else:
    print(a)
Buggy code:
a,b = [int(x) for x in input().split()]

if b =>a:
  print(a)
else:
  print(a-1)

Fixed code:
a,b = [int(x) for x in input().split()]
 
if b >= a:
  print(a)
else:
  print(a-1)
Buggy code:
a, b = (input().split(" "))
a = int(a)
b = int(b)
if a<b:
    print(a)
else:
    print(a-1)

Fixed code:
a, b = (input().split(" "))
a = int(a)
b = int(b)
if a<=b:
    print(a)
else:
    print(a-1)
Buggy code:
a, b = map(int, input().split())
r = a-1
if b-a>0:
    r+=1
print(r)

Fixed code:
a, b = map(int, input().split())
r = a-1
if b-a>=0:
    r+=1
print(r)
Buggy code:
a, b = map(int, input().split())

if a<b:
  print(a)
else:
  print(a-1)

Fixed code:
a,b = map(int,input().split())
if b < a:
    a -= 1
print(a)
Buggy code:
a,b=map(int,input().split())

print(a) if a<b else print(a-1)

Fixed code:
a,b = map(int, input().split())
print(a - (1 if b < a else 0))
Buggy code:
a,b = map(int,input().split())
if a >= b:
  print(a-1)
else:
  print(a)


Fixed code:
a,b = map(int,input().split())
if a > b:
  print(a-1)
elif a == b:
  print(a)
else:
  print(a)
Buggy code:
if __name__ == '__main__':
  a, b = map(int, input().split())
  if a >= b:
    print(a)
  elif a < b:
    print(b)

Fixed code:
if __name__ == '__main__':
    a, b = map(int, input().split())
    if a > b:
        print(a-1)
    elif a <= b:
        print(a)
Buggy code:
a, b = map(int,input().split()) 
if a < b:
  print(a)
  
else:
  print(a-1)

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

if b < a:
  print(a - 1)
else:
  print(a)
Buggy code:
lis = list(map(int,input().split()))
K = int(input())
s=sum(lis)-max(lis)+max(lis)**K
print(s)

Fixed code:
lis = list(map(int,input().split()))
K = int(input())
s=sum(lis)-max(lis)+max(lis)*2**K
print(s)
Buggy code:
L = sorted(list(map(int,input().split())))
k = int(input())
L[-1] = 2**k*L[-1]
print(sum(L))
print(L)


Fixed code:
L = sorted(list(map(int,input().split())))
k = int(input())
L[-1] = 2**k*L[-1]
print(sum(L))
Buggy code:
l=list(map(int,input().split()))
l.sort()
k=int(input())
print(l[0]+l[1]+l[2]**k)

Fixed code:
l=list(map(int,input().split()))
l.sort()
k=int(input())
print(l[0]+l[1]+l[2]*(2**k))
Buggy code:
a,b,c=map(int,input().split())
k=int(input())

print(a+b+c+max(a,b,c) * (k**2-1))

Fixed code:
a,b,c=map(int,input().split())
k=int(input())
m=max(a,b,c)

print(m*2**k +a+b+c - m)
Buggy code:
A, B, C = map(int, input().rstrip().split())
K = int(input())
print(2*(K-1)*max(A,B,C)+A+B+C)

Fixed code:
A, B, C = map(int, input().rstrip().split())
K = int(input())
print(2**K*max(A,B,C)+A+B+C-max(A,B,C))
Buggy code:
a,b,c = list(map(int,input().split()))
k = input()

BIG = max(a,b,c)
if BIG == a:
  print(BIG*(2**k)+b+c)
elif BIG == b:
  print(BIG*(2**k)+a+c)
else:
  print(BIG*(2**k)+a+b)


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

BIG = max(a,b,c)
if BIG == a:
  print(BIG*(2**k)+b+c)
elif BIG == b:
  print(BIG*(2**k)+a+c)
else:
  print(BIG*(2**k)+a+b)
Buggy code:
a = list(map(int, input().split()))
a.sort()
print(pow(2, k) * a[2] + a[1] + a[0])

Fixed code:
a = list(map(int, input().split()))
k = int(input())
a.sort()
print(pow(2, k) * a[2] + a[1] + a[0])
Buggy code:
A = list(map(int,input().split()))
A.sort()
k = int(input())
ans = sum(A[:2]) + A[3]*(2**k)

Fixed code:
A = list(map(int,input().split()))
A.sort()
k = int(input())
ans = sum(A[:2]) + A[2]*(2**k)
print(ans)
Buggy code:
ABC = list(map(int, input().split()))
K = int(input())

print(max(ABC)*(K-1) + sum(ABC))

Fixed code:
ABC = list(map(int, input().split()))
K = int(input())

print(max(ABC)*(2**K - 1) + sum(ABC))
Buggy code:
l = sorted(map(int, input().split()))
k = int(input())
l[2] = l[2] * k ** 2
print(sum(l))


Fixed code:
l = sorted(map(int, input().split()))
k = int(input())
l[2] = l[2] * (2 ** k)
print(sum(l))
Buggy code:
p=input;a=[i for i in p().split()];print(sum(a)+max(a)*2**int(p()))

Fixed code:
p=input;a=[int(i)for i in p().split()];m=max(a);print(sum(a)-m+m*2**int(p()))
Buggy code:
s=list(map(int,input().split()))
k=int(input())
s.sort()
m=1
m *= s[2]*k
print(m+s[0]+s[1])

Fixed code:
s=list(map(int,input().split()))
k=int(input())
s.sort()
m=1
m *= (s[2]*(2**k))
print(m+s[0]+s[1])
Buggy code:
li=list(map(int,input().split())).sort()
a=li.pop(-1)
k=int(input())
a=a*(2**k)
for i in li:
  a+=i
print(a)


Fixed code:
li=sorted(list(map(int,input().split())))
a=li.pop(-1)
k=int(input())
a=a*(2**k)
for i in li:
  a+=i
print(a)
Buggy code:
l=list(map(int,input().split()))
k=int(input())
m=max(l)
l.pop(l.index(m))
print(sum(l)+m**k)

Fixed code:
l=list(map(int,input().split()))
k=int(input())
m=max(l)
l.pop(l.index(m))
print(sum(l)+m*(2**k))
Buggy code:
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
l = list(map(int, input().split()))
K = int(input())
print(sum(l)+(max(l))*(K-1))


Fixed code:
# python template for atcoder1
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
l = list(map(int, input().split()))
K = int(input())
ans = sum(l)-max(l)
ans += max(l)*(2**K)
print(ans)
Buggy code:
x = list(map(int, input().split()))
k = int(input())
ans = sum(x) - max(x)
ans += max(x) ** k
print(ans)

Fixed code:
x = list(map(int, input().split()))
k = int(input())
ans = sum(x) - max(x)
ans += max(x) * 2 ** k
print(ans)
Buggy code:
a, b, c = map(int, input().split())
k = int(input())

print(max(a,b,c)**(2*k)+a+b+c-max(a,b,c))

Fixed code:
a,b,c=map(int,input().split())
k=int(input())
t=max(a,b,c)
print(a+b+c+(t*2**k)-t)
Buggy code:
a, b, c = map(int, input().split())
K = int(input())
m = max(a, b, c)
print(a + b + c + 2**(K-1) * m)

Fixed code:
a, b, c = map(int, input().split())
K = int(input())
m = max(a, b, c)
print(a + b + c + (2**K - 1) * m)
Buggy code:
A, B, C = input().split()
K = int(input())

A = int(A)
B = int(B)
C = int(C)

X = (A, B, C)
M = max(X)
print(M ** K + A + B + C -M)

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

A = int(A)
B = int(B)
C = int(C)

X = (A, B, C)
M = max(X)
print(M * (2 ** K) + A + B + C -M)
Buggy code:
numbers = list(map(int, input().split()))
K = int(input())
max_index = numbers.index(max(numbers))
result = 0
print('max: ', numbers[max_index])
result = [numbers[i] * 2 ** K if i == max_index else numbers[i] for i in range(len(numbers))]
print(sum(result))

Fixed code:
numbers = [int(i) for i in input().split()] 
K = list(map(int, input().split()))[0]
max_index = numbers.index(max(numbers))
result = [numbers[i] * 2 ** K if i == max_index else numbers[i] for i in range(len(numbers))]
print(sum(result))
Buggy code:
a=list(sorted(map(int,input().split())))
k=int(input())
print(sum(a)+a[-1]**2*(k-1)-a[-1])

Fixed code:
a=list(sorted(map(int,input().split())))
k=int(input())
print(sum(a)+a[-1]*2**k-a[-1])
Buggy code:
N=list(map(int,input().split()))
K=int(input())
NN = sorted(N, reverse=True)
print(sum(NN[0:K]) * 2 + sum(NN[K:])) 


Fixed code:
N=list(map(int,input().split()))
K=int(input())
NN = sorted(N, reverse=True)

print(NN[0] * 2 ** K + sum(NN[1:]))
Buggy code:
a, b, c = sorted([ int(v) for v in input().split() ])
n = int(input())
print(a+b+c*(2**k))

Fixed code:
a, b, c = sorted([ int(v) for v in input().split() ])
k = int(input())
print(a+b+c*(2**k))
Buggy code:
a,b,c,k=map(int,input().split()),int(input())
print((a+b+c-max(a,b,c))+max(a,b,c)*2**k)

Fixed code:
a, b, c = map(int, input().split())
k = int(input())
print(max(a, b, c)*((2**k)-1) + a + b + c)
Buggy code:
l = list(map(int, input().split()))
K = int(input())
l.sort()
a = l.pop()
print(a ** K + sum(l))

Fixed code:
l = list(map(int, input().split()))
K = int(input())
l.sort()
a = l.pop()
print((2 ** K) * a + sum(l))
Buggy code:
a, b, c = sorted(map(int, input().split()), reverse=True)
k = int(intpu())
print(a*2**k + b + c)


Fixed code:
a, b, c = sorted(map(int, input().split()), reverse=True)
k = int(input())
print(a*2**k + b + c)
Buggy code:
a, b, c = list(map(int, input().split()))
k = int(input())

print(a+b+c-max(a,b,c)+max(a,b,c)*(k**2))

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

print(a+b+c+(2**k-1)*max(a,b,c))
Buggy code:
X = list(map(int, input().split()))
K = int(input())
print(sum(X) + max(X)*2**(K-1))

Fixed code:
X = list(map(int, input().split()))
K = int(input())
print(sum(X) + max(X)*(2**K-1))
Buggy code:
A,B,C=map(int,input().split())
K=int(input())
M=max(max(A,B),C)
print(M**K+A+B+C-M)


Fixed code:
A,B,C=map(int,input().split())
K=int(input())
M=max(max(A,B),C)
print(M*(2**K)+A+B+C-M)
Buggy code:
a,b,c=map(int,input().split())
k=int(input())

print(sum(a,b,c)-max(a,b,c)+max(a,b,c)*(2**k))

Fixed code:
a, b, c = map(int, input().split())
k = int(input())
ans = a+b+c+max(a, b, c)*2**k-max(a, b, c)
print(ans)
Buggy code:
a=list(map(int,input().split()))
k=int(input())
b=[0,0,0]
n=1

for i in range(0,2):
    if a[i]==max(a):
        a[i]=a[i]*(2**k)


print(sum(a))

Fixed code:
a=list(map(int,input().split()))
k=int(input())
b=[0,0,0]
n=1

for i in range(0,3):
    if a[i]==max(a):
        a[i]=a[i]*(2**k)


print(sum(a))