TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=input().split()
S+=T
print(S)

S,T=input().split()
T+=S
print(T)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()
print(t+" "+s)

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input()
t = input()
print("{}{}".format(t, s))

s, t = input().split()
print("{}{}".format(t, s))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input()
t = input()
print(t+s)

s=input()
t=input()
print(t+s)

S,T = input().split()
print(T+S)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()
print(s+t)


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


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String a = s.nextLine();
        String b = s.nextLine();
        String c = b.concat(a);
        System.out.println(c);
    }
}


s = input().split()
print(s[1]+s[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S = input()
T = input()

print("%s%s" % (T, S))

S, T = [i for i in input().split()]

print("%s%s" % (T, S))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = input().split()
print("{}{}".format(S, T))


S, T = input().split()
print("{}{}".format(T, S))


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A,B,K = map(int,input().split())

Q = K - A
q = A - K
if Q < 0 :
  print (q)
if Q >= 0 :
  W = B - Q
  if W >= 0:
    print ("0",W)
  if W< 0 :
    print("0 0")

S = input()
T = input()
print(T + S)

S,T = input().split()
print(T+S)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import sys

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

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
def connect(a, b):
  return b + a

s = input()
t = input()
print(connect(s, t))

def connect(s):
  return s[1] + s[0]

s = input().split()
print(connect(s))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = input().split()

A = S+T

print(A)

S = input()
T = input()

print(T+S)

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

print(T+S)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().replace(" ", ""))

print(input().strip())


s, t = map(str, input().split())
print(t+s)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b,k = map(int, input().split())


if a >= k:
    print('{} {}'.format(a-k,b))

elif (a + b) > k:
    print('0 {}'.format(a+b-k))

elif (a + b) < k:
    print('0 0')

s,t =input().split()

ans =''

print(ans + t + s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
    s, t = input().split()
    
    print(t + s)

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().split()[::-1])

print(''.join(input().split()[::-1]))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=map(str,input().split())

print(S+T)

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

print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
n,k=map(str,input().split())
print(n,end="")
print(k)


n,k=map(str,input().split())
print(k,end="")
print(n)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a=input()
b=input()
print(b+a)

a,b=input().split()

print(b+a)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b,k = map(int,input().split())
if a-k < 0:
    b  = b + a -k
a = max(a-k,0)
print(a,max(b,0))

s,t = map(str,input().split())
print(t ,end='')
print(s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=map(str,input().split())
print(T,S)

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


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = map(int, input().split())
print(T + S)

S, T = input().split()
print(T + S)


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A,B,K = input().split()
x=0
while (int(A)>0):
  x=int(x)+1
  A=int(A)-1
  if(x>int(K)):
    break
while (int(B)>0):
  x=int(x)+1
  B=int(B)-1
  if(x>int(K)):
    break
if(A>0):
  A=int(A)+1
if(B>0):
  B=int(B)+1
print(format(A)+' '+format(B))

x=0
A,B,K = input().split()
while (int(A)>0):
  x=int(x)+1
  A=int(A)-1
  if(x>int(K)):
    break
while (int(B)>0):
  x=int(x)+1
  B=int(B)-1
  if(x>int(K)):
    break
if(A>0):
  A=int(A)+1
if(B>0):
  B=int(B)+1
print(format(A)+' '+format(B))

A,B,K = input().split()
x=0
while (int(A)>0):
  x=int(x)+1
  A=int(A)-1
  if(x>int(K)):
    break
while (int(B)>0):
  x=int(x)+1
  B=int(B)-1
  if(x>int(K)):
    break
if(A>0):
  A=int(A)+1
if(B>0):
  B=int(B)+1
print(format(A)+' '+format(B))

S,T = input().split()
print (T+S)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b = input().split()
print(a+b)

a,b = input().split()
print(a,b,sep ='')

a,b = input().split()
print(b,a,sep ='')

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=input()
t=input()
print(t+s)

s=input()
t=input()
print('t'+'s')

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = 'T' + 'S'

print(s)

S = 'aaa'
T = 'bbb'

A = S + T

print(A)

S = 'aaa'
T = 'bbb'
 
A = T + S
 
print(A)

s = 'S' + 'T'

print(s)

str1 = 'T'
str2 = 'S'
str1+= str2 
print(str1) 

str1 = 'T'
str2 = 'S'
str3 = str1+str2
print(str3)

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

s = T + S
print(s)

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S = input() 
T = input() 
print(S+T)

S,T = input().split()
print(S+T)

S,T = input().split()
print(T+S)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input()
t = input()
print(t+s)

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input() 
t = input()

print(t + s)

A,B,K = map(int, input().split())
while K >=1:
    if A >= 1:
        A = A - 1
    elif B >= 1:
        B = B - 1
    K = K -1
print(A, B)

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t map(str, input().split())
ans = t + s
print(ans)

s, t = map(str, input().split())
ans = t + s
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
 y= list(map(str,input().rstrip().split()))
print(y[1]+y[0])

x = list(map(str,input().rstrip().split()))
print(x[1]+x[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = map(str,input().split())
print ( S + T )


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


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=input().split()
print('S'end'')
print('T')


S,T=map(input().split())
print('{}{}'.format(T,S))
      

S,T=map(input().split())
print('S'end'')
print('T')


S,T=map(input().split())
print('{T}{S}'.format(S,T))
      

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=input()
t=input()
print(t+s)

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
"""
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)


"""
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)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = map(str, input().split())
print(s+t)

s,t = map(str, input().split())
print(t+s)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A, B, K = map(int, input().split())
while K > 0:
  if A > 0:
    A = A - 1
    K = K - 1
  elif A == 0 and B > 0:
    B = B - 1
    K = K - 1

print(str(A) + " " + str(B))

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=map(str,input().split())
print(S+T)

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,D= map(str,input().split())
print(S+D)

S,D= map(str,input().split())
print(D+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print("".join(map(str,input().split())))


print("".join(list(reversed(list(map(str,input().split())))))


print("".join(list(reversed(list(map(str,input().split()))))))

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S = input()
T = input()
print(T + S)

ST = input()
S, T = ST.split(" ")
print(T + S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b=map(str,input().split())
print(a+b)

a,b=map(str,input().split())
print(a+b)

a,b=map(str,input().split())
print(b+a)


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a, b = map(str, input().split())

print(b, a)

a, b = map(str, input().split())

print(b + a)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = map(str,input().split())
print(S+T)

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
#A
s, t = list(map(str,input().split()))
print(''.join(s+t))

#A
s, t = list(map(str,input().split()))
print(''.join(t+s))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=map(input().split())
print(s+t)

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b,k=(long(i)for i in input().split())
while 0<k:
    if 0<a:a=a-1
    elif 0<b:b=b-1
    k=k-1
print(a,b)


s=input().split()
print(s[1]+s[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
# -*- coding: utf-8 -*-

S = input()
T = input()
print(T+S)

# -*- coding: utf-8 -*-

S,T = input().split()
print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A,B,K = map(int,input().split())

a = 0
b = 0

if A <= 10**12 and B <=10**12 and K <= 10**12:
    if A >= K :
        a = A-K
    elif  (A + B) >=K:
        a = 0
        b = B-(K-A)
    elif  (A + B)  < K:
        a = 0
        b = 0
else :
    a = 0
    b = 0

print(a,b,end='')

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

print(T,S,sep ='')

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input()
t = input()
print("{}{}".format(t,s))

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = input().split()
print(S+T)

S,T = input().split()
print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().replace(" ", ""))

a, b = input().split(" ")
a += b
print(a)

a, b = input().split(" ")
b += a
print(b)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input()
print(s+t)

s,t = input()
print(t+s)

s = input().split()
print(s[1]+s[0])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b = map(int,input().split())
print(b+a)

s,t = map(str,input().split())

print(t+s)


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a, b, k = map(int, input().split())
if a >= k:
    a -= k
else:
    b = max(0,k - a)
    a = 0
print(a, b)

s, t = map(input().split())
print(s, t,sep='')

s, t = input().split()
print(s,t,sep='')

s, t = input().split()
print(t,s,sep='')

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()

print(s+t)

s,t = input().split()

print(s+t)

s,t = input().split()

print(t+s)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = list(map(int, input().split()))

print(T+S)

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

print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
def main():
  def stringConcat(s,t):
    return t+s
  
print(main())

def concStrings(s, t):
  return t+s

s = input('')
t = input('')

print(t+s)

taka, aoki, action = map(int, input().split())
 
if taka >= action:
  print(taka-action, aoki)
  
else:
  print(0, max(taka+aoki-action, 0))

a,b,k=map(int, input().split()) 
if a>=k:
  print(a-k,b)
else:
  print(0,max(a-k+b, 0))

s, t = input().split()

print(t+s)

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=input().split()
print(S+T)

S,T=input().split()
print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
def f(S,t):
    return T+S
S=input()
T=input()
print(f(S,T))


def f(S,T):
    return T+S
S,T= map(str,input().split())
print(f(S,T))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
first, second = map(str, input().split())
print(first + second)

first, second = map(str, input().split())
print(second + first)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = list(map(str,input().split()))
print(S + T)

S, T = list(map(str,input().split()))
print(T + S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()

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

s, t = input().split()

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=list(map(str,input().split()))
print(s+t)


s,t=list(map(str,input().split()))
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=map(str,input().split())
print(s,t,sep="")


s,t=map(str,input().split())
print(t,s,sep="")


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=map(input().split())
print(s+t)

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

s=input()
t=input()
print(s+t)

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(*list(input().split()),sep="")

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b = map(str, input().split())
print(a+b)

a,b = map(str, input().split())
print(b+a)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
T,S = map(str,input().split())

print(T + S)

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

print(T + S)

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

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a, b = input().split()
print(a+b)

a, b = input().split()
print(b+a)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b,k=map(int,input().split())
if a<k:
	b=max(b-(k-a),0)
	a=0
else:
	a=a-k
print(a,end=' ')
print(b)

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=input().split()
print(S+T)


S,T=input().split()
print(T+S)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input()
t = input()

print(t+s)

s,t = map(input().split())

print(t+s)

s,t = input().split()

print(t+s)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print("".join(input().split()[::-1])

print("".join(input().split()[::-1]))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
# -*- coding: utf-8 -*-
"""
Created on Sat Jan  4 16:21:16 2020

@author: masat
"""

S, T = input().split()

print(S+T)



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

@author: masat
"""

S, T = input().split()

print(T+S)



Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input()
t = input()

print(t+s)

S,T=input().split()
print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input()
print(t+s)

s, t = map(input())
print(t+s)

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print(" ".join(t, s))

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=input().split()
ans= ""
for i in range(len(s)):
    ans += s[i]
print(ans)

s=input().split()
ans= ""
for i in range(len(s)):
    ans += s[len(s)-1-i]
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=input().split('')
print(T+S)

S,T=input().split(' ')
print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split(" ")
print(s+t)

s, t = input().split(" ")
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().replace(" ", ""))

print("".join(input().split(" ")[::-1]))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=input().split()
t+s

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
x,y = map(str,input().split())
x += y
print(x)

x,y = map(str,input().split())
y += x
print(y)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S = str(input())
T = str(input())

print(T+S)

String= list(map(str, input().split()))
print(String[1] + String[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
#include<stdio.h>
int main() {
	char s[100], t[100];
	scanf("%s %s", s,t);
	for (int i = 0; i != '\0'; i++) {
		printf("%c", t[i]);
	}
	for (int j = 0; j != '\0'; j++) {
		printf("%c", s[j]);
	}
	
	return 0;
}

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A, B, K = input().split()

Takahashi = int(A)
Aoki = int(B)
count = int(K)

t = 0

for i in range(count):
    Takahashi = Takahashi-1
    t = t+1
    if t == count:
        break
    elif Takahashi < 0:
        Takahashi = 0
        Aoki = Aoki-1
        t = t+1
        if Aoki == 0:
            print(Takahashi, Aoki)
            break
    else:
        continue


print(Takahashi, Aoki)

word1 = input()
word2 = input()

print(word1 + word2)

A, B, K = input().split()

Takahashi = int(A)
Aoki = int(B)
count = int(K)

t = 0

for i in range(count):
    Takahashi = Takahashi-1
    t = t+1
    if t == count:
        break
    elif Takahashi < 0:
        Takahashi = 0
        Aoki = Aoki-1
        t = t+1
        if Aoki == 0:
            print(Takahashi, Aoki)
            break
    else:
        continue


print(Takahashi, Aoki)

word1, word2 = input().split()

print(word1 + word2)

word1, word2 = input().split()

print(word2 + word1)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b,k=map(int,input().split())
if a>=k:
  a1=a-k
  print(a1,b)
else:
  a1=0
  if b>=k-a:
    b1=b-(k-a)
  else:
    b1=0
  print(a1,b1)


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


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=map(input()split())
print(T.S)

S,T=input().split()
S=T+S
print(S)


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print("".join(input().split()))

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):

A, B, K = map(int, input().strip().split(" "))

if A > K:
    A -= K
    K = 0

else:
    K -= A
    A = 0

if B > K:
    B -= K
    K = 0

else:
    B = 0
    
print("{} {}".format(A, B))


N, K = map(int, input().strip().split(" "))
R, S, P = map(int, input().strip().split(" "))
T = list(input())

point = {
    "r": P,
    "s": R,
    "p": S
}

score = 0

for i in range(N):

    tmp = i - K
    if 0 <= tmp and T[i] == T[tmp]:
        score += 0
        T[i]=""

    else:
        score+= point[T[i]]
print(score)



S, T = input().strip().split(" ")

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=str(input())
t=str(input())
print(t+s)

l=list(map(str,input().split()))
print(l[1]+l[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = input().split()
ptint(T+S)

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

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b = input()
print(b+a)

a,b = input().split()
print(b+a)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = input().split()
print(S+T)

S,T = input().split()
print(T+S)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import sys

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

main()

import sys

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

main()

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
# -*- coding: utf-8 -*-
import sys
# INPUT
input = list(map(int, input().split()))

s = input[0]
t = input[1]

ans = t
print(t+s)


# -*- coding: utf-8 -*-
import sys
# INPUT
input = list(map(str, input().split()))

s = input[0]
t = input[1]

print(t+s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = input().split()

print(S+T)

S,T = input().split()

print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
data = input().split()

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = map(str,input().split())
print(''.join(map(str,S+T)))

S, T = map(str,input().split())
print(''.join(map(str,T+S)))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,  T = input().split()
print("".join(T,S))

import sys
input = sys.stdin.readline
def print_ans(S):
    """Test Case
    >>> print_ans(["oder",  "atc"])
    atcoder
    """
    print("".join(S[::-1]))

if __name__ == '__main__':
    S = list(input().rstrip().split())
    print_ans(S)




Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
num = list(input().split())
print(num[0]+num[1])

num = list(input().split())
print(str(num[0])+str(num[1]))

num = list(input().split())
po = num[0]+num[1]
print(po)

num = list(input().split())
print(str(num[1])+str(num[0]))

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b,k=map(int,input().split())

if k<=a:
  print(str(a-k)+' '+str(b))
  
else:
  print(str(0)+' '+str(min(0,b-(k-a))))


s,t=map(str,input().split())

print(t+s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = map(str, input().split())

print(S+T)

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

print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))



X=int(input())

prime_l=[0]*(2*X)
for  i in range(2,X):
    if(prime_l[i]==0):
        for j in range(1,(2*X)//i):
            prime_l[i*j]+=1
        
while(1):
    X+=1
    if(prime_l[X]==0):
        print(X)
        sys.exit(0)


import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

S=ns().split()
print(S[1]+S[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input().split()

print(''.join(s))


s = input().split()
s = reversed(s)
print(''.join(s))


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
from itertools import accumulate

a = list(range(1, 11))
b = list(accumulate(a))     
print(a)
print(b)

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

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a, b, n = list(map(int, input().split()))

if (a + b) <= n:
  a = 0
  b = 0
else:
  if n > a:
    b -= n-a
    a = 0
    if b < 0:
      b = 0
  else:
    a = (n-a)

print("%d %d" %(a,b))

a, b = list(map(str, input().split()))
print(b+a)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a, b = input().split()
print(a, b, sep="")

a, b = input().split()
print(b, a, sep="")

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
ST = split.input()
print(ST[1] + ST[0], sep = "")

ST = input().split()
print(ST[1] + ST[0], sep = "")

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T =input().split()
print("T"+"S")

S,T =input().split()
print(T,S)

a,b,k=map(int,input().split())
if k<=a:
	A=a-k
	B=b
elif k>=a and k<=b:
	A=0
	B=b+a-k
else:A=B=0
print(A,B)


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

S,T = .input().split()
print(T+S)


S,T=.input().split()
print(TS)

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

a,b,k=map(int,input().split())
if k<=a:
	print(a-k,b)
elif k>=a and k<=b:
	print(a-a,b+a-k)
else: print(0 0)


S,T =input().split()
print(T+S)

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = map(int, input().split())
print(s + t)


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


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = input().split()
print(T, S, end="")

print("".join(input().split()))

S, T = input().split()
print(T, S, sep="")

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
# A - Strings

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


# A - Strings

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


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()

print(s + t)

s, t = input().split()

print(t + s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
x = int(input())
flg = 0
_flg = 1
while flg == 0:
    mx  = int(x**0.5)
    for i in range(2, mx+1):
        if x % i == 0:
            _flg = 0
            break
    fig = _flg
    if flg == 0:
        x+=1
print(x)


s, t = map(str, input().split())
print(t+s)


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S = input("文字列Sを入力")
T = input("文字列Tを入力")
txt = S + T
print(txt)

S = input().split()
T = input().split()
txt = S + T
print(txt)

S, T = input()
txt = S + T
print(txt)

S = input()
T = input()
txt = S + T
print(txt)

moji_s=input("文字列Sを入力:")
moji_t=input("文字列Tを入力:")
print(moji_s + moji_t)

S = input().split()
T = input().split()
print(S + T)

S, T = input()
print(S + T)

S = input()
T = input()
print(S + T)

S, T = input().split()

print(T + S)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b = input().split()
print(a+b)

a = input()
t = ''
for c in a:
    if c != ' ':
        t+=c
print(t)

a,b = input().split()
print(b+a)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S=input()
T=input()

print(T+S)

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


print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S = input()
T = input()

m = T + S
            
print(m)

S,T = input().split()

print(T + S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=input().split()
print(s[0]+s[1])


s=input().split()
print("".join(s))


print(input().strip())

print(input().replace(" ",""))


s=input().split()
print(s[1]+s[0])


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted