qyliang/CodeNanoFix huggingface dataset:
Buggy code:
s,t = input().split
print(s + t)

Fixed code:
s, t = input().split()

print( t + s )
Buggy code:
a,b=input().split()
print(b,a sep='')


Fixed code:
a,b=input().split()
print(b,a, sep='')
Buggy code:
t,s=map(input().split())
print(s+t)


Fixed code:
t,s=map(str,input().split())
print(s+t)
Buggy code:
a,b = input().split()
print (a + b)

Fixed code:
a,b = input().split()
print (b + a)
Buggy code:
import sys

S, T = next(sys.stdin).strip().split()
print(T, S)

Fixed code:
import sys
 
S, T = next(sys.stdin).strip().split()
print(T + S)
Buggy code:
a, b = map(str, input().split())

print(b, a)

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

print(b + a)
Buggy code:
import sys

def main():
    l=sys.stdin.readline().split()
    print l[1]+l[0]

main()

Fixed code:
import sys

def main():
    l=sys.stdin.readline().split()
    print(l[1]+l[0])

main()
Buggy code:
s, t = input().split()
print(s, t, sep="")

Fixed code:
s, t = input().split()
print(t, s, sep="")
Buggy code:
S,T = .input().split()
print(T+S)


Fixed code:
S, T = list(input().split())

print(T + S)
Buggy code:
s, t = input().split()
print(s + t)


Fixed code:
s, t = input().split()

print(t + s)
Buggy code:
st=input().split(' ')
print(st[0]+st[1])

Fixed code:
st=input().split()
print(st[1]+st[0])
Buggy code:
A, B = input().split()
print(B, A)

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

print(B+A)
Buggy code:
#S,T = map(int,input().split())
S,T = input().split()
#S = input()
print(S+T)

Fixed code:
#S,T = map(int,input().split())
S,T = input().split()
#S = input()
print(T+S)
Buggy code:
s,t = input.split()
print(t.lower()+s.lower())

Fixed code:
s,t = input().split()
print(t.lower() + s.lower())
Buggy code:
S,T=map(str,input().split())
print(T,S)

Fixed code:
S, T = map(str, input().split())

print(str(T+S))
Buggy code:
S, T=input().split()
print(S+T)

Fixed code:
S, T = input().split()
print(T +S)
Buggy code:
a = input().split()

print("".join(a))

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

print("".join(reversed(a)))
Buggy code:
s, t = map(input().split())

x = t + s
print(x)

Fixed code:
s, t = map(str, input().split())
 
x = t + s
print(x)
Buggy code:
S, T = map(str, input().split())

print(S,end="")
print(T)

Fixed code:
S, T = map(str, input().split())

print(T,end="")
print(S)
Buggy code:
S,T=input().split()
print(S + T)

Fixed code:
S,T = input().split(" ")

print(T+S)
Buggy code:
str = input(.split(' '))

print(str[1]+str[0])

Fixed code:
s = str(input()).split(" ")
print(s[1] + s[0])
Buggy code:
s,t = input().split(" ")
print(t+" "+s)

Fixed code:
s,t = input().split()
print(t+s)
Buggy code:
S,T=input().split()
res=S+T
print(res)

Fixed code:
S,T=input().split()

print(T+S)
Buggy code:
s = input().split()

print(''.join(s))


Fixed code:
s = input().split()
s = reversed(s)
print(''.join(s))
Buggy code:
num = list(input().split())
print(num[0]+num[1])

Fixed code:
num = list(input().split())
print(str(num[1])+str(num[0]))
Buggy code:
    s, t = input().split()
    print(t+s)

Fixed code:
s, t = input().split()

print(t+s)
Buggy code:
line = input()
s, t = line.split(" ")
ans = s + t
print(ans)


Fixed code:
line = input()
s, t = line.split(" ")
ans = t + s
print(ans)
Buggy code:
S,D= map(str,input().split())
print(S+D)

Fixed code:
S,D= map(str,input().split())
print(D+S)
Buggy code:
inputted = input().split()
S = inputted[0] 
T = inputted[1]

answer  = S + T

print(answer)


Fixed code:
inputted = input().split()
S = inputted[0] 
T = inputted[1]

answer = T + S

print(answer)
Buggy code:
s,t = map(str,input().split())
print(s+t)

Fixed code:
s,t=map(str, input().split())
print(t+s)
Buggy code:
if __name__ == '__main__':
    a, b = input().split(' ')
    print(a+b)

Fixed code:
if __name__ == '__main__':
    a, b = input().split(' ')
    print(b+a)
Buggy code:
s,t=map(str,input().split())
print(s,t,sep="")


Fixed code:
s,t=map(str,input().split())
print(t,s,sep="")
Buggy code:
s, t = map(str, input().split())
print(s + t)

Fixed code:
s, t = map(str, input().split()) 
print(t + s)
Buggy code:
S, T = map(str, input().split())

print("{}{}",format(T, S))

Fixed code:
S, T = map(str, input().split())

print("{}{}".format(T, S))
Buggy code:
H,W = [x for x in input().split()]
print(H+W)

Fixed code:
H,W = [x for x in input().split()]
print(W+H)
Buggy code:
S, T = list(map(str,input().split()))
print(S + T)

Fixed code:
S, T = list(map(str,input().split()))
print(T + S)
Buggy code:
s,t = map(input().split())
print(t+s)


Fixed code:

s,t = map(str,input().split())
print(t+s)
Buggy code:
s, t = input().split(" ")
print(s+t)

Fixed code:
s, t =  input().split() 

print(t+s)
Buggy code:
S, T = map(str, input().split())


def solve():
    return S + T


print(solve())


Fixed code:
S, T = map(str, input().split())


def solve():
    return T + S


print(solve())
Buggy code:
from sys import stdin
S, T = stdin.readline().rstrip().split()

print(S+T)


Fixed code:
from sys import stdin

S, T = stdin.readline().rstrip().split()

print(T+S)
Buggy code:
n = input()
(p,q) = n.split()
print(p+q)

Fixed code:
n = input()
(p,q) = n.split()
print(q+p)
Buggy code:
S,T=map(input().split())
print('{T}{S}'.format(S,T))
      

Fixed code:
S,T=map(str,input().split())
print('{}{}'.format(T,S))
Buggy code:
S,T = input().split()
print(S,T)

Fixed code:
S, T = input().split()
print(T + S)
Buggy code:
S, T= map(str, input().split())
print(S + T)

Fixed code:
S , T = map(str, input().split())
print(T + S)
Buggy code:
S,T = input().split()
print(S,T, sep='')

Fixed code:
S,T = input().split()
print(T,S, sep='')
Buggy code:
s,t=input().split()
print=(t+S)

Fixed code:
s,t  = input().split()
print(t+s)
Buggy code:
s,t=map(str,input.split())
print(t+s)

Fixed code:
s,t = map(str, input().split())
print(t+s)
Buggy code:
S, T = input().split
print(T, S, sep='')

Fixed code:
S, T = input().split()
print(T, S, sep='')
Buggy code:
S, T = map(str, input.split())
A = T[:] + S[:]
print(A)

Fixed code:
S, T = map(str, input().split())
A = T[:] + S[:]
print(A)
Buggy code:
a, b = input().split()
print(a+b)

Fixed code:
a, b = input().split()
print(b+a)
Buggy code:
#A
s, t = list(map(str,input().split()))
print(''.join(s+t))

Fixed code:
#A
s, t = list(map(str,input().split()))
print(''.join(t+s))
Buggy code:
S,T = map(str,input().split())
print(S + T)


Fixed code:
S,T = map(str,input().split())
print(T + S)
Buggy code:
a, b = map(input().split())
print(b + a)

Fixed code:
a, b = input().split()
print(b + a)
Buggy code:
a,b=map(str,input().split())
print(a+b)

Fixed code:
a,b = map(str,input().split())
print(b+a)
Buggy code:
s,t = map(input().split())
print(s+t)

Fixed code:
t,s = input().split()
print(s+t)
Buggy code:
#<ABC149>
#<A>
S, T = map(str,input().split())
print(S+T)


Fixed code:
#<ABC149>
#<A>
S, T = map(str,input().split())
print(T+S)
Buggy code:
s,t=map(str,input().split())
print(s+t)

Fixed code:
s , t = map(str , input().split())
print(t + s)
Buggy code:
S,T = input().split()


ans = S + T

print(ans)

Fixed code:
S,T = input().split()


ans = T + S

print(ans)
Buggy code:
# -*- coding: utf-8 -*-

S, T=map(str, input().split())

print(S+T)

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

S, T=map(str, input().split())

print(T+S)
Buggy code:
S,T = input().split()
str=S+T

print(str)


Fixed code:
S,T = input().split()
str=T+S

print(str)
Buggy code:
s,t = input().split()
print(s + t) 

Fixed code:
s,t = input().split()
print(t + s)
Buggy code:
import os
nyu = input().split()
S=nyu[0].strip()
T=nyu[1].strip()
print(S+T)

Fixed code:
import os
nyu = input().split()
S=nyu[0].strip()
T=nyu[1].strip()
print(T+S)
Buggy code:
s,t = (i for i in input().split())
print(s+t)

Fixed code:
s,t = (i for i in input().split())
print(t+s)
Buggy code:
b,a = input().split()
print(''.join([a,b].strip())

Fixed code:
b,a = input().split()
print(''.join([a,b]).strip())
Buggy code:
a = list(map(str, input().split()))
print("{} {}".format(a[1], a[0]))

Fixed code:
a = list(map(str, input().split()))
print("{}{}".format(a[1], a[0]))
Buggy code:
# -*- coding: utf-8 -*-
s, t = input().split()
res = s + t
print(res)

Fixed code:
# -*- coding: utf-8 -*-
s, t = input().split()
res = t + s
print(res)
Buggy code:
s, t = input().split()
print('{}{}'.format(s,t))

Fixed code:
s, t = input().split()
print('{}{}'.format(t,s))
Buggy code:
s, t = map(str, input().split())
print(t,s)

Fixed code:
s, t = map(str, input().split())
print(t+s)
Buggy code:
# -*- coding: utf-8 -*-
a, b = input().split()
pirnt("{}{}".format(b,a))


Fixed code:
# -*- coding: utf-8 -*-
a, b = input().split()
print("{}{}".format(b,a))
Buggy code:
# -*- coding: utf-8 -*-
"""
Created on Sat Jan  4 16:21:16 2020

@author: masat
"""

S, T = input().split()

print(S+T)



Fixed code:
# -*- coding: utf-8 -*-
"""
Created on Sat Jan  4 16:21:16 2020

@author: masat
"""

S, T = input().split()

print(T+S)
Buggy code:
str_list = input().split()
str = str_list[0] + str_list[1]
print(str)

Fixed code:
str_list = input().split()
str = str_list[1] + str_list[0]
print(str)
Buggy code:
l = input().split()
print(l[0]+l[1])

Fixed code:
l = input().split()
print(l[1]+l[0])
Buggy code:
from sys import stdin
strings = list(stdin.readline().split())
print(string[1] + string[0])


Fixed code:
from sys import stdin
strings = list(stdin.readline().split())
print(strings[1] + strings[0])
Buggy code:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a, b = input().split()
print(a+b)

Fixed code:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a, b = input().split()
print(b+a)
Buggy code:
ST = input().split()
s = ""
s += ST[0]
s += ST[1]
print(s)

Fixed code:
s = input().split(" ")

print(s[1] + s[0])
Buggy code:
S,T = map(input().split())
U = ""
U = U + T + S
print(U)

Fixed code:
S,T = input().split()
U = ""
U = U + T + S
print(U)
Buggy code:
n = str(input())
n_list = n.split(" ")
n_list0 = n_list[0]
n_list1 = n_list[1]
mojiretsu = n_list0 + n_list1
print(mojiretsu)

Fixed code:
n = str(input())
n_list = n.split(" ")
n_list0 = n_list[0]
n_list1 = n_list[1]
mojiretsu = n_list1 + n_list0
print(mojiretsu)
Buggy code:
S, T = map(input().split())
print(T+S)

Fixed code:
S, T = input().split()

print(T + S)
Buggy code:
chars = input().split(" ")
print(chars[0]+chars[1])

Fixed code:
chars = input().split(" ")
print(chars[1]+chars[0])
Buggy code:

if __name__ == "__main__":
    A, B = input().split()
    print(A + B)

Fixed code:

if __name__ == "__main__":
    A, B = input().split()
    print(B + A)
Buggy code:
first, second = map(str, input().split())
print(first + second)

Fixed code:
first, second = map(str, input().split())
print(second + first)
Buggy code:
S, T = [int(i) for i in input().split()]
print(T+S)

Fixed code:
S, T = [i for i in input().split()]
print(T+S)
Buggy code:
a = input.split()
print(a[1] + a[0])

Fixed code:
a = input().split()
print(a[1] + a[0])
Buggy code:
S,T = map(input().split())
print(T+S)

Fixed code:
S, T = input().split()

print (T+S)
Buggy code:
S,T=input().split(" ")
print(S+T)

Fixed code:
S,T=input().split(" ")
print(T+S)
Buggy code:
n,k=map(str,input().split())
print(n,end="")
print(k)


Fixed code:
n,k=map(str,input().split())
print(k,end="")
print(n)
Buggy code:
list= list(input().split())
print(list[0]+list[1])

Fixed code:
list= list(input().split())
print(list[1]+list[0])
Buggy code:
s, t = input().split
print(t + s)

Fixed code:
s,t=input().split()
s=t+s
print(s)
Buggy code:
# coding: utf-8

import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

S, T = input().split()

print(S + T)


Fixed code:
# coding: utf-8

import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

S, T = input().split()

print(T + S)
Buggy code:
a,b=input().split()
for i in a,b:
  print(i,end="")

Fixed code:
a,b=input().split()
for i in b,a:
  print(i,end="")
Buggy code:
S,T=input().split()
S+=T
print(S)

Fixed code:
S,T=(input().split())
print(T+S)
Buggy code:
S, T = input().split()

ans = S + T

print(ans)


Fixed code:
S, T = input().split()
print(T+S)
Buggy code:
s,t = input().split()
s+=t
print(s)

Fixed code:
text=input()

s,t=text.split()

print(t+s)
Buggy code:
    S, T = map(str, input().split())

    print(T + S )

Fixed code:
S, T = map(str, input().split())

print(T + S )
Buggy code:
a, b = (int(i) for i in input().split())  
print("{}{}".format(b, a))

Fixed code:
a, b = (i for i in input().split())
print("{}{}".format(b, a))
Buggy code:
a,b = input().split()
ans = a+b
print(ans)

Fixed code:
a,b = input().split()
ans = b+a
print(ans)
Buggy code:
s, t = input().split()
print(s + t)

Fixed code:
s,t = input().split()
t += s
print(t)
Buggy code:
a, b = input().split()
print(a, b, sep="")

Fixed code:
a, b = input().split()
print(b, a, sep="")
Buggy code:
a,b=map(str,input().split())
print(a,end="")
print(b)

Fixed code:
a,b=map(str,input().split())
print(b,end="")
print(a)
Buggy code:
a,b = map(str,input().split())
print(b+c)


Fixed code:
a,b = map(str,input().split())
print(b+a)
Buggy code:
a,b = input().split()

print(a+b, sep = "")

Fixed code:
a, b = input().split()
print(b,a, sep='')
Buggy code:
def main():
    s, t = input().split()
    ans = ''.join([s, t])
    print(ans)


if __name__ == '__main__':
    main()


Fixed code:
def main():
    s, t = input().split()
    ans = ''.join([t, s])
    print(ans)


if __name__ == '__main__':
    main()
Buggy code:
S = input().split()
print(S[0]+S[1])

Fixed code:
S = input().split()
print(S[1]+S[0])
Buggy code:
print("".join(input().split()[-1]))


Fixed code:
print("".join((input().split())[::-1]))
Buggy code:
from sys import stdin
a,b = [x for x in stdin.readline().rstrip().split()]
print(a+b)

Fixed code:
from sys import stdin
a,b = [x for x in stdin.readline().rstrip().split()]
print(b+a)
Buggy code:
def solve(s, t):
    return s + t

s, t = input().split()
print(solve(s, t))

Fixed code:
def solve(s, t):
    return t + s

s, t = input().split()
print(solve(s, t))
Buggy code:
"""
author : halo2halo
date : 8, Jan, 2020
problem : ABC149

"""

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

S, T = read().split()
answer = T+S
print(answer)


Fixed code:
"""
author : halo2halo
date : 8, Jan, 2020
problem : ABC149
"""

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

S, T = read().decode('utf-8').split()

answer = T + S
print(answer)
Buggy code:
s,t = input().split()

print(s+t)


Fixed code:
s,t = input().split()
ans = t+s

print(ans)
Buggy code:
s,t = input().split()
print(t, end=" ")
print(s)

Fixed code:
s, t = input().split()
print(t, end="")
print(s)
Buggy code:
S,T = map(str,input().split())

print(S+T)

Fixed code:
S,T = map(str,input().split(' '))
print(T+S)
Buggy code:
a,b = input().split()
print(a,end="")
print(b)

Fixed code:
a,b = input().split()
print(b,end="")
print(a)
Buggy code:
s, t = map(str, input().split())
print(''.join([s, t]))


Fixed code:
s, t = map(str, input().split())
print(''.join([t, s]))
Buggy code:
A, B = (input().split())
print(B,A)

Fixed code:
A, B = (input().split())
print(B+A)
Buggy code:
s,t = map(input().split())

print(t+s)

Fixed code:
s,t =input().split()

print(t+s)
Buggy code:
def stringconcant(S,T):
    x = S
    b = T
    c = x+b
    return c

S,T= input().split()
x = stringconcant(T,S)
print(a)

Fixed code:
def stringconcant(S,T):
    a = S
    b = T
    c = a+b
    return c

S,T= input().split()
a = stringconcant(T,S)
print(a)
Buggy code:
inp = str(input()).split(" ")
print(inp[0]+inp[1])

Fixed code:
inp = str(input()).split(" ")
print(inp[1]+inp[0])
Buggy code:
S,T = input().split()
 
print(S+T)

Fixed code:
S, T = input().rstrip().split()
print(T+S)
Buggy code:
S, T = map(input().split())
print('{}{}'.format(T, S))

Fixed code:
S, T=map(str, input().split())
print('{}{}'.format(T,S))
Buggy code:
# coding: utf-8
import numpy as np
from functools import lru_cache
import time

def main(): 
    if True:
        N,X = list(map(str, input().split()))
    else:
        pass
    print(N+X)



if __name__ =='__main__':
    main()

Fixed code:
# coding: utf-8
import numpy as np
from functools import lru_cache
import time

def main(): 
    if True:
        N,X = list(map(str, input().split()))
    else:
        pass
    print(X+N)



if __name__ =='__main__':
    main()
Buggy code:
# -*- coding: utf-8 -*-
 
n, k = map(str, input().split())
print(n+k)

Fixed code:
# -*- coding: utf-8 -*-
 
n, k = map(str, input().split())
print(k+n)
Buggy code:
s,t = input().split( )
print(s+t)

Fixed code:
s,t = input().split( )
print(t+s)
Buggy code:
a=input().split()
print(a[0]+a[1])


Fixed code:
a=input().split();print(a[1]+a[0])
Buggy code:
s,t = map(str, input().split())
print(s+t)

Fixed code:
s,t = map(str, input().split())
print(t+s)
Buggy code:
s,t=map(input().split())
ans=t+s
print(ans)

Fixed code:
s,t=input().split()
ans=t+s
print(ans)
Buggy code:
ST = split.input()
print(ST[1] + ST[0], sep = "")

Fixed code:
ST = input().split()
print(ST[1] + ST[0], sep = "")
Buggy code:
S, T = input().split();print(S + T)

Fixed code:
S , T = input().split()

print(T + S)
Buggy code:
s,t = input().split()
print(s + t)

Fixed code:
s, t = str(input()).split()
print(t + s)
Buggy code:
S,T = str(input()).split()

print(S+T)

Fixed code:
S, T = input().split()

print(T + S)
Buggy code:
S, T = map(str, input().split())
print(S+T)

Fixed code:
S,T = list(map(str,input().split()))
print(T + S)
Buggy code:
s,t = input().split()
print(t+" "+s)

Fixed code:
s,t= input().split()
print(t+s)
Buggy code:
word1, word2 = input().split()

print(word1 + word2)

Fixed code:
word1, word2 = input().split()

print(word2 + word1)
Buggy code:
s=input().split()
print(s[0]+s[1])


Fixed code:
s = input().split(' ')
print(s[1]+s[0])
Buggy code:
A, B = map(input().split())
print(B + A)

Fixed code:
A, B = input().split()
print(B + A)
Buggy code:
A,B = map(str,input().split())
out = A+B
print(out)

Fixed code:
A,B = map(str,input().split())
out = B+A
print(out)
Buggy code:
def main():
    [s, t] = input().split()
    print(s + t)

if __name__ == "__main__":
	main()

Fixed code:
def main():
    [s, t] = input().split()
    print(t + s)

if __name__ == "__main__":
	main()
Buggy code:
S,T = input().split()

A = S+T

print(A)

Fixed code:
T , S = input().split()
print(S +T)
Buggy code:
# -*- coding: utf-8 -*-

import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

S, T = input().split()

print(S + T)


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

import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

S, T = input().split()

print(T + S)
Buggy code:
s, t = input().split()

print("%s%s" %(s,t))

Fixed code:
s, t = input().split()

print("%s%s" %(t,s))
Buggy code:
a,b=input(),split()
print(a+b)

Fixed code:
a,b=input().split()
print(b+a)
Buggy code:
a,b = input().split()
print(a,b,sep ='')

Fixed code:
a,b = input().split()
print(b,a,sep ='')
Buggy code:
S,T = map(input().split())
ans = T+S
print(ans)


Fixed code:
S,T = input().split()
ans = T+S
print(ans)
Buggy code:
S,T=map(str,input().split())
print(S+T)

Fixed code:
S, T = input().split()
S = str(S)
T = str(T)
print(T+S)
Buggy code:
def main():
    a, b = input().split()
    print(a + b)


if __name__ == '__main__':
    main()


Fixed code:
def main():
    a, b = input().split()
    print(b + a)


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

Fixed code:
a,b,k = map(int,input().split())
if a <= k: 
    k -= a
    a = 0
    b -= k
    if b < 0: b = 0
else:
    a -= k
print(a,b)
Buggy code:
#!/usr/bin/env python3
import sys


def solve(A: int, B: int, K: int):
    for i in range(K):
        if A >= 1:
            A -= 1
        elif B>=1:
            B-=1
        else:
            break
    print(A,B)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    solve(A, B, K)

if __name__ == '__main__':
    main()

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


def solve(A: int, B: int, K: int):
    if A <= K:
        K -= A
        A = 0
        if B <= K:
            B = 0
        else:
            B-=K
    else:
        A -= K
    print(A,B)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    solve(A, B, K)

if __name__ == '__main__':
    main()
Buggy code:
a, b, k = int(i) for i in input().split()
takahashi = a - k
aoki = b + takahashi if takahashi < 0 else b
print(f"{max(takahashi, 0)} {max(aoki, 0)}")


Fixed code:
a, b, k = (int(i) for i in input().split())
takahashi = a - k
aoki = b + takahashi if takahashi < 0 else b
print("{} {}".format(max(takahashi, 0), max(aoki, 0)))
Buggy code:
a,b,k = int(input().split())
if k > a:
  a=0
  k-=a
  if k > b:
    b=0
  else:
    b-=k
else:
  a-=k
print(' '.join([a,b])

Fixed code:
a,b,k = map(int,input().split())
if k > a:
  k-=a
  a=0
  if k > b:
    b=0
  else:
    b-=k
else:
  a-=k
print(' '.join([str(a),str(b)]))