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):
X =int(input())
def f(n):
    for i in range(2,int(n**0.5)+1):
        if n%i == 0:
            return False
    return True
for i in range(X,100004):
    if f(i):
        return(i)
        break

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):
a,b=map(int,input().split())
print(b+a)

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(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):
x = int(input())
 
for val in range(x, x**1000) :
	if x ==2 :
		print(x)
		break
	elif ((10** val) % val) == 10 :
		print (val)
		break
	else :
		continue

S = input()
T = input()

U = T + S
print(U)

x = int(input())
 
for val in range(x, x**1000) :
	if x ==2 :
		print(x)
		break
	elif ((10** (val-1)) % val) == 1 :
		print (val)
		break
	else :
		continue

x = int(input())
 
for val in range(x+1, x**100) :
	if x ==2 :
		print(x)
		break
	elif ((2** val) % val) == 2 :
		print (val)
		break
	else :
		continue

x = int(input())
 
for val in range(x, x**100) :
	if x ==2 :
		print(x)
		break
	elif ((10** val) % val) == 10 :
		print (val)
		break
	else :
		continue

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

U = T + S
print(U)

Verdicts: 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,k=map(int,input().split())
 
for a,b in range(k):
	if a >=  1:
    	a -= 1
  
	elif a < 1 and b >= 1:
		b -= 1
	else:
      	break
        
print (a,b,end=" ")

a,b,k = map(int,input().split())
 
for a,b in range(k):
	if a >=  1:
        a -= 1
  
	elif a < 1 and b >= 1:
        b -= 1
	else:
        break
        
print (a,b,end=" ")

a,b,k=map(int,input().split())
 
for a,b in range(k):
	if a >=  1:
      a -= 1
  
	elif a < 1 and b >= 1:
      b -= 1
	else:
      break
        
print (a,b,end=" ")

a,b,k=map(int,input().split())
 
for a,b in range(k):
	if a >=  1:
    	a -= 1
  
	elif a < 1 and b >= 1:
		b -= 1
        
print (a,b)

a,b,k=map(int,input().split())
 
for a,b in range(k):
	if a >=  1:
    	a -= 1
  
	elif a < 1 and b >= 1:
		b -= 1
	else:
      	break
        
print (a,b,end=" ")

a,b,k = map(int,input().split())
 
for a,b in range(k):
	if a >=  1:
            a -= 1
  
	elif a < 1 and b >= 1:
            b -= 1
	else:
            break
        
print (a,b,end=" ")

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

Verdicts: 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,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):
n,k=map(int,input().split())
r,s,p=map(int,input().split())
t=input()
point=0
l=[]
point_list=[r,s,p]
kind=['r','s','p','r']
for i in range(n):
  for j in range(len(kind)-1):
    if t[i]==kind[j]:
      if i-k>=0 and t[i]==kind[l[i-k]+1]:
        if i+k<n and t[i+k]==kind[j+1]:
          if j==2:j=-1
          l.append(j+1)
        else:
          l.append(j)
      else:
        point+=point_list[j-1]
        if j==0:j=3
        l.append(j-1)
      break
print(point)

str1,str2=input().split()
print(str2+str1)

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= input()
b= input()
print(b+a)

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

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

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

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):
S, T = map(str, input().split())


def solve():
    return S + T


print(solve())


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


def solve():
    return T + S


print(solve())


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())
print(max(0,a-k),max(0,b-max(0, k-a)))

s,t=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):
# -*- 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)


# -*- 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)


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):
s,t = map(str,input().split())
print(s +t)

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

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().strip()
print(B+A)

A, B = input().strip()
print(A+B)

def isPrime(n):
    if n == 1: return False
 
    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False
 
    return True
  
num = input()
 
res = True
ans = 0
if num > 2 and num%2 == 0:
  num += 1
while(res):
  if isPrime(num):
    print(num)
    break
  num += 2

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

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

Verdicts: Wrong Answer

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,k =  input().split()
a = int(a)
b = int(b)
k = int(k)
if a <= k:
    i = 0
    m = b - (k-a)
else:
    i = a-k
    m=b
print(i,m)
    

    

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

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):
li = list(input())
print(li[1]+li[0])

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

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):
string = input().split()
print(string[1]+string[0]

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

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

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

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):
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 = 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):
def main():
	s,t =input().split
	print(t+s)
main()

def main():
	s,t =input().split()
	print(t+s)
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):
s = input().split()
print("".join(s))

s = input().split()
t=[]
t.append(s[1])
t.append(s[0])
print("".join(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):
s1 = input()
s2 = input()
print(s2 + s1)

s1 = input()
s2 = input()
s3 = s2 + s1
print(s3)



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



s1 = input()
s2 = input()
print(s2 + s1)



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



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):
print("".join(input().split(" ")))


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):
from math import sqrt
X = int(input())
def is_prime_next(X):
    X_sqrt = int((sqrt(X)-5)/6) 
    if X==2 or X==3:
        return X
    if X%2 == 0:
        return None
    if X%3 == 0:
        return None
    for i in range(1, X_sqrt):
        if X % (6*i+1) == 0 or X % (6*i+5) == 0:
            return None
    return X
while(1):
    X_keep = is_prime_next(X)
    if X_keep != None:
        break
    X += 1
print(X)

S, T = map(str, input().split())
T += S
print(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):
a,b = map(int,input().split())
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=(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 = map(input().split())
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=intput().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 = input()
b = input()
print(b+a, end="")

a = input()
b = input()
print(b+a)

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().rstrip()
print(t + s)


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


s, t = input().rstrip().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(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(str(input()) + str(input()))

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

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=int(input()) 
T=int(input())
print(T+S)

a,b,k=map(int,input().split())
if k>=a:
  A=0
  if k-a>=b:
    B=0
  else:
    B=b-(k-a)
else:
  A=a-k
  B=b
print('{}{}'.format(A,B))


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

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 = 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):
function sort(S,T){
  var str1=S;
  
  var str2 =T;
  var res=(str1.split("")).concat(str2.split(""));
  return res;
}

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

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

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

Verdicts: Runtime Error

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 = [int(i) for i in input().split()]
a = A - (K - (K -A))
b = B - (K - A)
print(f"{a} {b}")

a,b = [i for i in 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):
print(''.join(input().split()))

s,t = input().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):
a,b = map(str,input().split())
print(b+c)


a,b = 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):
print(*input().split()[::-1])

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, 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):
first, second = [input().split()]
print(second+first)

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

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):
if __name__ == '__main__':
    a, b = input().split(' ')
    print(a+b)

if __name__ == '__main__':
    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):
T=input()
S=input()
print(T + S)

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):
k,x = [int(x) for x in input().split()]

k = k * 500 

if k >= x:
  print("Yes")
else:
	print("No")

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):
a,b =map(str,input().split())
print("b+a")

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):
S, T = input().split()
print(S+T)

S = input()
T = input()

print(S+T)

S, T = 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):
input_list = list(map(int, input().split()))
games = input_list[0]
temp = input_list[1]
input_list = list(map(int, input().split()))
r = input_list[0]
s = input_list[1]
p = input_list[2]
target = input()

def no_win_hand(next_hand):
  myhand = win_janken(next_hand)
  return myhand

def get_point(myhand):
  if myhand == 'r':
    point = r
  elif myhand == 's':
    point = s
  else:
    point = p
  return point

def win_janken(hand, next_hand = 'non', donate = 'non'):
  if hand == 'r':
    myhand = 'p'
  elif hand == 's':
    myhand = 'r'
  else:
    myhand = 's'
  point = get_point(myhand)
  if myhand == donate:
    nothand = no_win_hand(next_hand)[0]
    select_hands = ['r','s','p']
    for hand_1 in select_hands:
      if hand_1 is not donate and  hand_1 is not nothand:
        myhand = hand_1
    point = 0
  return myhand, point

allpoint = 0
for m in range(temp):
  group = ''
  for ind, n in enumerate(target):
    if ind % temp == m:
       group += n
  points = 0
  myhands =''
  for index, string in enumerate(group):
    if len(myhands) > 0:
      donate = myhands[index - 1]
    else:
      donate = 'non'
    if index < len(group) - 1:
      myhand, point = win_janken(string, group[index + 1], donate)
    else:
      myhand, point = win_janken(string, 'non', donate)
    points += point
    myhands += myhand
  allpoint += points
print(allpoint)

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


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

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):
# -*- coding: utf-8 -*-

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

print(S+T)

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

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(t, s, sep='')

s, t = 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):
print(input() + input())

print(input() + input())

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())
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=map(int, input().split())
print(a+b)

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

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

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):
test1 = input()
test2 = input()

ans = test2 + test1

print(ans)

test1, test2 = input().split()

ans = test2 + test1

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):
return "".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):
l = input().split()
print(l[0]+l[1])

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

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())
ans = a + b
print(ans)

a , b =map(str,input().split())
ans = b + a
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+c)

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 = list(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):
s,t = raw_input.split()
print(t+s)

print(''.join(sorted(S+T)))

s,t = raw_input.split()
print(t.lower() + s.lower())

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

print(''.join(sorted(S+T)))

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

Verdicts: 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):
x, y = map(int,input().split())
print(y+x)

print(y+x)

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

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):
S,T=map(int, input().split())
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,t = list(map(int, input().split()))
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):
A - Strings

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


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(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(string, input().split())
print(S+T)

S,T=map(string,input().split())
ans=T+S
print(ans\n)

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(input().replace(" ", ""))

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):
class CookieCalc:
  def __init__(self, t_cookie, a_cookie):
    self.takahashi_cookie = t_cookie
    self.aoki_cookie = a_cookie
    
  def eat_cookie(self):
    if self.takahashi_cookie > 0:
      self.takahashi_cookie-=1
    elif self.aoki_cookie > 0:
      self.aoki_cookie -= 1
      
  def sum_cookie(self):
    return self.takahashi_cookie + self.aoki_cookie
      
t_cookie,a_cookie,K = [int(s) for s in input().split()]
cookie = CookieCalc(t_cookie, a_cookie)
 
for i in range(K):
  cookie.eat_cookie()
  if cookie.sum_cookie() == 0:
    break
    
  
print(cookie.takahashi_cookie, cookie.aoki_cookie)  

import math

def is_prime(x):
  if x <= 1:
    return False
  max_judge = math.sqrt(x)
  count = 2
  while(count < max_judge):
    if x % count == 0:
      return False
    count+=1
  return True
 
x = int(input())
 
judge_prime = False

while(True):
  if is_prime(x):
    break
  x+=1

print(x)

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

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


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=input()
b=input()
print(a+b)

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

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

a,b=str(input().lower()).split()
s=a+b
print(s[:101])

a=str(raw_input())
b=str(raw_input())
print(a+b)

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

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

a=str(input())
b=str(input())
print(a+b)

a,b=str(input().lower()).split()
s=a+b
print(s[0:100])

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

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

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

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

Runtime Error

Wrong Answer

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()
printf(s+t)

s, t = 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):
n = int(input())


def prime(n):
    if n == 1:
        n += 1
    while True:
        flag = 0
        for k in range(2, int(n**0.5) + 1):
            if n % k == 0:
                flag = 1
                break
        if flag == 0:
            return n
        n += 1


ans = prime(n)
print(ans)


a = input().split()
print(a[1]+a[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(T + S )

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

    print(T + S )

S, T = map(str, 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):
a,b,k=map(int,input().split())
if a>=k:
  print(a-k,b)
elif b>=(k-a):
  print(0,b-k+a)
else:
  print(0,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 = map(int, input().split())

for i in range(k):
    if a > 0:
        a = a - 1
    elif b > 0:
        b = b - 1

print(a, 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=input().split()
print("".join(S))

S=input().split()
print("".join(S[::-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 = str(input())
t = str(input())
print(t + s)

i = str(input()).split(" ")
print(i[1] + i[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(s+t)

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):
n = str(input())
n_list = n.split(" ")
n_list0 = n_list[0]
n_list1 = n_list[1]
mojiretsu = n_list0 + n_list1
print(mojiretsu)

n = str(input())
n_list = n.split(" ")
n_list0 = n_list[0]
n_list1 = n_list[1]
mojiretsu = n_list1 + n_list0
print(mojiretsu)

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()
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):
ST = input().split()
s = ""
s += ST[0]
s += ST[1]
print(s)

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

ST = input().split()
s = ""
s += ST[1]
s += ST[0]
print(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):
x = int(input())
while True:
    if x % 2 != 0:    
        for m in range(3,int(x**0.5)+4,2):
            if x % m == 0 and x < m:
                break
        else:
            break
    x += 1
print (x)

a = input()
b = a.split()
print (b[1]+b[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 = list(map(str, input().split()))

O = "".join(S)

print(O)



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

O = T+S 

print(O)

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=str(input())
a=t+s
print(a)

s,t=map(str,input().split())
a=t+s
print(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=input("")
t=input("")
print(str(s)+str(t))


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):
print(input().replace(" ", ""))

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

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("{}{}".format(s, t))

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

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

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

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

Verdicts: Wrong Answer

Wrong Answer

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 = str(input()).split()

print(S+T)

s, t = 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()

ans = S + T

print(ans)


S, T = input().split()

ans = T + S

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):
inp = str(input()).split(" ")
print(inp[0]+inp[1])

a = input()
b = input()

print(a+b)

inp = input().split(" ")
takahashi = int(inp[0])
aoki = int(inp[1])
K = int(inp[2])

for i in range(K):
    if takahashi > 0 :
        takahashi = takahashi -1
    elif aoki > 0 :
        aoki = aoki-1

print(str(takahashi) + " " + str(aoki))

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

Verdicts: Wrong Answer

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, K = map(int, input().split())


if A + B <= K:
	print(0, 0)
elif A < K:
	print(0, B - (K - A))
else:
	print(K - A, 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):
# 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()

# 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()

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:
  print(A-K,B)
elif B-(K-A) >= 0:
  print(0,B-(K-A))
else:
  print(0,0)

s = list(map(str, 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().strip()
t = input().strip()
print(t+s)

s=input()
s=input()+s
ptint(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):
a[0] = input()
a[1] = input()
print a[1] + a[0]

a, b= (int(i) for i in input().split())
print b + a

L,R = input().split()
print R + L

a[0] = input()
a[1] = input()
print a[0] + a[1]

print (sys.argv[2]+ sys.argv[1])

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

a[0] = input()
a[1] = input()
print (a[1] + a[0])

L,R = input().split()
k = R + L
print (k)

Verdicts: 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):
import math
x=int(input())
primemode = True
while primemode:
  sos = True
  for n in range(math.floor(math.sqrt(x))):
    if n+1 != 1:
      if x%(n+1) == 0:
        sos = False
  if sos:
    primemode = False
  else:
    x = x+1
print(x)

import math
x=int(input())
primemode = True
while primemode:
  x = x+1
  sos = True
  for n in range(math.floor(math.sqrt(x))):
    if n+1 != 1:
      if x%(n+1) == 0:
        sos = False
  if sos:
    primemode = False
print(x)

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

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):
S,T = input().split()

U = S+T
print(U)


S,T = input().split()

U = T+S
print(U)


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(S+T,end="")

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):
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):
a,b=input().split()
print(b,a sep='')


a,b=input().split()
print(b,a, 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 = map(str, input().split(" "))
print(s+t)


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

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):
S,T=map(str,input().split())
print(S+T)

A,B,K=map(int,input().split())
for x in range(K):
    if A>=1:
        A-=1
    else:
        B-=1
print(A,B)

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):
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):
a, b, k = map(int, input().split())
for i in range(k):
  if a > 0:
    a -= 1 
  elif b > 0:
    b -= 1
  else:
    break
print(str(a) + " " + str(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):
A, B, K = [int(i) for i in input().split()]
if K <= A:
    a = A-K
    b = B
elif A < K and K <= A+B:
    a = 0
    b = B-(K-A)
else:
    a = 0
    b = 0
print(a, b)


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

print(T+S)


Verdicts: Runtime Error

Accepted