Problem:
 Score : 100 points    Problem Statement 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.      Constraints  S and T are strings consisting of lowercase English letters.  The lengths of S and T are between 1 and 100 (inclusive).         Input Input is given from Standard Input in the following format:  S  T       Output Print the resulting string.        Sample Input 1 oder atc      Sample Output 1 atcoder  When S =  oder and T =  atc , concatenating T and S in this order results in atcoder .       Sample Input 2 humu humu      Sample Output 2 humuhumu

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
import random
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def StoI():
    return [ord(i)-97 for i in input()]
def ItoS(nn):
    return chr(nn+97)
def GI(V,E,Directed=False,index=0):
    org_inp=[]
    g=[[] for i in range(n)]
    for i in range(E):
        inp=LI()
        org_inp.append(inp)
        if index==0:
            inp[0]-=1
            inp[1]-=1
        if len(inp)==2:
            a,b=inp
            g[a].append(b)
            if not Directed:
                g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp
            aa=(inp[0],inp[2])
            bb=(inp[1],inp[2])
            g[a].append(bb)
            if not Directed:
                g[b].append(aa)
    return g,org_inp
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)]
        rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()

input=lambda: sys.stdin.readline().rstrip()

def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

show_flg=False
show_flg=True

ans=0
s,t=input().split()

    
ans=t+s
print(ans)

Solution (Python):
a,b=input().split()
print(b+a)

Solution (Python):
import sys
input = sys.stdin.readline
S,T=input().rstrip().split()

def resolve():
    print(T+S)

import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """oder atc"""
        output = """atcoder"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """humu humu"""
        output = """humuhumu"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

Solution (Python):
s,t=map(str,input().split())

print(t+s)

Solution (Python):
s,t =input().split()
print(t+s)

Solution (Python):
s, t = input().split(' ')
print(t+s)

Solution (Python):
s,t = input().split()

print("{}{}".format(t,s))

Solution (Python):
a,b= input().split()
print(b+a)

Solution (Python):
S, T = input().split()
print(T+S)

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

Solution (Python):
S,T=input().split()
print(T+S)

Solution (Python):
S,T = input().split()
print(T+S)

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

Solution (Python):
S,T=input().split()
print("".join([T,S]))

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):
s, t = [x for x in input().split()]
print(t+s)

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

print(T+S)

Solution (Python):

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

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):


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

Solution (Python):
s,t = map(str,input().split())

print(t+s)

Solution (Python):

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

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

Solution (Python):
S , T  = input().rstrip().split()
print("{}{}".format(T, S))

Solution (Python):
S,T = input().split()
print(T+S)

Solution (Python):
s, t = map(str, input().split(' '))

print("{0}{1}".format(t, s))

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

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

def main():
  s,t=LS()
  return t+s


print(main())

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

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

Solution (Python):
s, t = input().split()
print(t + s)

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

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):
import sys
input = sys.stdin.readline
import numpy as np
S, T = input().split()
print(T + S)

Solution (Python):
import sys
from random import choice,randint
inp=sys.stdin.readline
out=sys.stdout.write
flsh=sys.stdout.flush
 
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
 
def MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()]
def LF(): return [float(x) for x in inp().strip().split()]
def LS(): return inp().strip().split()
def I(): return int(inp().strip())
def F(): return float(inp().strip())
def S(): return inp().strip()
def pf(s): return out(s+'\n')
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)

def main():
    s,t=LS()
    print(t+s)

if __name__ == "__main__":
    main()

Solution (Python):
s,t=input().split()
print(t+s)

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

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

Solution (Python):
S,T = input().split()
print(T+S)

Solution (Python):
def main():
    ST = input().split(" ")
    S = ST[0]
    T = ST[1]

    ans = T + S

    print(ans)
 
if __name__ == '__main__':
    main()

Solution (Python):
s,t = input().split()
print(t + s )

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

Solution (Python):
st = input().split()
print(st[1]+st[0])

Solution (Python):
b, c = input().split()
print(c + b)

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):
a,b=input().split()
print(b+a)

Solution (Python):
S, T = input().split()

print (T+S)

Solution (Python):
s,t = input().split()
print(t+s)

Solution (Python):


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

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

Solution (Python):
s, t = input().split()
print(t + s)

Solution (Python):
s, t = input().split()

print(t + s)

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):
s,t=input().split()
print(t,s,sep="")

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):
def run(s, t):
    return t + s


def main():
    s, t = input().split()
    print(run(s, t))


if __name__ == '__main__':
    main()

Solution (Python):
s, t = input().split()
print(t + s)

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

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

Solution (Python):
s, t = str_list = input().split(' ')
print('%s%s' % (t,s))

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

Solution (Python):
s,t = input().split()

print(t+s)

Solution (Python):
import collections as c
ip = lambda : map(int, input().split())


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

Solution (Python):
S,T=input().split()

print(T+S)

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

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

Solution (Python):
S,T = input().split()
print(T+S)

Solution (Python):
import sys
input = sys.stdin.readline
S = input().split()
print(S[1] + S[0])

Solution (Python):
S, T =  input().split()

print(T + S)

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):
def main():
    s,t=input().split()
    print(t+s)
if __name__=='__main__':
    main()

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):
s,t = input().split()
string = t+s
print(string)

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


def main():
    S = input()[:-1].split()
    print(S[1] + S[0])


if __name__ == '__main__':
    main()

Solution (Python):
S,T = list(input().split())

print(T+S)

Solution (Python):
s, t = input().split()
print(t+s)

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

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

Solution (Python):

test = ""

"""
atc oder
"""

test = list(reversed(test.strip().splitlines()))
if test:
    def input2():
        return test.pop()
else:
    def input2():
        return input()

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

Solution (Python):
s,t = (i for i in input().split())

print(t+s)

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

Solution (Python):

MOD = 10 ** 9 + 7

import math

import itertools



def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def main():
    s,t=map(str,input().split())
    a=t+s
    print(a)











if __name__ == "__main__":
    main()

Solution (Python):
x = [i for i in input().split()]
x[0],x[1] = x[1],x[0]
print(''.join(map(str,x)))

Solution (Python):
s, t = input().split(" ")

print(t+s)

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

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

Solution (Python):
def main():
    strings = input().split(" ")
    print(strings[1] + strings[0])


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
import numpy as np




def main():
    s, t = input().split()
    print(t+s)
    return


if __name__ == "__main__":
    main()

Solution (Python):
s, t = map(str, input().split())

print(t + s)

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):
s, t = input().split(' ')

print(t + s)

Solution (Python):
n, m = input().split()
print(m+n)

Solution (Python):




import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline





s,t = [i for i in readline().split()]

print(t+s)

Solution (Python):
s, t = input().split()

print(t+s)

Solution (Python):

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

Solution (Python):
S, T = input().split()

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

Solution (Python):
S, T = input().split()
print(T + S)

Solution (Python):
S, T = input().split()
print(T + S)

Solution (Python):
a = input().split()
print(a[1] + a[0])

Solution (Python):
s,t = input().split()
print(t+s)

Solution (Python):
l = input().split()

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

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):
S = input().split()

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

Solution (Python):
s, t = map(str, input().split())
a = t+s
print(a)

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

Solution (Python):
S, T = input().split()
print(T + S)

Solution (Python):
S, T = list(input().split())

print(T + S)

Solution (Python):
s,t = input().split()		

print(t+s)

Solution (Python):
from sys import stdin
s,t = [x for x in stdin.readline().rstrip().split()]
print(t + s)

Solution (Python):
s, t = input().split()
print(t + s)

Solution (Python):
S, T = input().split()
print(T + S)

Solution (Python):
s, t = input().split()
print(t + s)

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):
A = input().split(" ")
print(A[1] + A[0])

Solution (Python):
S,T = input().split()
print(T+S)

Solution (Python):
import sys
input = sys.stdin.readline

S,T = input().split()

print(T+S)

Solution (Python):
S,T=input().split(" ")

print(T+S)

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):

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

Solution (Python):
s, t = map(str,input().split())

print(t + s)

Solution (Python):
import sys
import math
from collections import deque
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

s, t = SL()

print(t + s)

Solution (Python):
S = input().split()
ans = S[1]+S[0]
print(ans)

Solution (Python):
def solve(s, t):
    return t + s


def main():
    s, t = input().split()
    res = solve(s, t)
    print(res)


def test():
    assert solve("oder", "atc") == "atcoder"
    assert solve("humu", "humu") == "humuhumu"


if __name__ == "__main__":
    test()
    main()

Solution (Python):
A,B = list(map(str, input().split()))
print(B+A)

Solution (Python):
S, T = map(str, input().split())

print(T + S)

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

Solution (Python):
import sys
input = sys.stdin.readline
S,T = input().split()
K = T+S
print(K)

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):


def resolve():
    s, t = input().rstrip().split()

    print(t + s)

if __name__ == "__main__":
    resolve()

Solution (Python):
s,t=input().split()

print(t+s)

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

Solution (Python):
S,T=input().split()
print(T+S)

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

Solution (Python):
s,t = input().split()

print(t+s)

Solution (Python):
S, T = input().split()
print(T + S)

Solution (Python):
ST=input().split()

S=ST[0]
T=ST[1]

print(T+S)

Solution (Python):
import sys
import itertools
input = sys.stdin.readline


def read_values():
    return map(int, input().split())


def read_list():
    return list(read_values())


def read_lists(N):
    return [read_list() for n in range(N)]


def dfs(N, L, s):
    depth = [-1] * N

    stack = [(0, s)]
    while stack:
        d, p = stack.pop()
        depth[p] = d

        for q in L[p]:
            if depth[q] != -1:
                continue
            stack.append((d + 1, q))
    return depth

    
def main():
    S, T = input().split()

    print(T + S)


if __name__ == "__main__":
    main()

Solution (Python):
S,T = input().split()
print(T+S)

Solution (Python):
S,T = input().split()
print(T+S)

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

Solution (Python):
S,T = map(str,input().split())
A = T+S
print(A)

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):
s,t = input().split()
print(t+s)

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

Solution (Python):
def main():
    s, t = input().split()
    print(t + s)


if __name__ == "__main__":
    main()

Solution (Python):
S,T = input().split()
print(T+S)

Solution (Python):
S , T = input().split()

print(T + S)

Solution (Python):
s,t = input().split()
a=[t,s]
ans="".join(a)
print(ans)

Solution (Python):
S, T = input().split()

print(T + S)

Solution (Python):
S, T = input().split()
print(T + S)

Solution (Python):
s,ss = map(str,input().split())
print(ss+s)

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

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

Solution (Python):
from heapq import heappush, heappop
from collections import deque
import re
import math
import functools

def sRaw():
    return input().rstrip("\r")

def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29


def make1d_arr(n, val=INF):
    return [val for i in range(n)]


def make2d_arr(h, w, val=INF):
    return [[val for i in range(w)]for i in range(h)]


def gcd(a, b):
    if(b == 0):
        return a
    return gcd(b, a % b)


def BFord(n,es):
    v_cost = [INF]*n
    v_cost[0] = 0
    for v in range(n*2):
        for e in es:
            frm = e[0]
            to = e[1]
            if v_cost[to] > v_cost[frm]+e[2]:
                v_cost[to] = v_cost[frm]+e[2]
                if v >= n:
                    v_cost[to] = -INF
        if v == n-1:
            prev = v_cost[:]
    v_cost = [-INF if prev[idx]!=v_cost[idx] else v_cost[idx] for idx in range(n)]
    return v_cost
    
def ZAlgo(s):
    l = len(s)
    A = [0]*l
    i =1
    j =0
    A[0]=l
    while i<l:
        while i+j<l and s[j] == s[i+j]:
            j+=1
        if j==0:
            i+=1
            continue
        A[i]=j
        k=1
        while (i+k<l) and (k+A[k]<j):
            A[i+k] =A[k]
            k+=1
        i+=k
        j-=k
    return A


DIV = 998244353

def main():
    Ss = ssRaw()
    return "".join(Ss[::-1])

if __name__ == "__main__":

    print(main())

Solution (Python):
s = input()
s2 = s.split()
print("".join([s2[1], s2[0]]))

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

Solution (Python):
s, t = input().split()
print(t + s)

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

Solution (Python):
S, T = input().split()

print(T+S)

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):
S, T = map(str, input().split())

ans = ''

ans += T
ans += S

print(ans)

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]

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

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

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):
s,t = input().split()
print(t+s)

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

Solution (Python):
s, t = input().split()

print(t+s)

Solution (Python):

A,B = map(str, input().split())
print(B+A)

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

Solution (Python):
A,B=input().split()
print(B+A)

Solution (Python):
s, t = list(input().split(" "))

print(t + s)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

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

Solution (Python):
def main():
    s,t = input().split()
    print(t+s)
        
if __name__ == '__main__':
    main()

Solution (Python):
s, t = input().split()
res = t+s
print(res)

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
s,t = [i for i in input().split()]
print(t+s)

Solution (Python):
s,t = map(str, input().split())
print('{}{}'.format(t,s))

Solution (Python):
s, t = map(str, input().split())

print(t + s)

Solution (Python):
S,T = (i for i in input().split())
print(T+S)

Solution (Python):
S,T = input().split()

print(T+S)

Solution (Python):
a, b = input().split()
print(b+a)

Solution (Python):
def main():
    s , t = map(str,input().split())
    print(t+s)


if __name__ == '__main__':
    main()

Solution (Python):
S, T = input().split()

print(T + S)

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

Solution (Python):
s,t = input().split()
print(t+s)

Solution (Python):
def solve():
  S, T = input().split()
  return T + S

print(solve())

Solution (Python):


def main():
    S, T = input().split()
    print(T+S)
if __name__ == '__main__':
    main()

Solution (Python):
s,t = map(str, input().split())

print("".join([t,s]))

Solution (Python):
print "".join(raw_input().split()[::-1])

Solution (Python):
S, T = map(str, input().split())

print(T + S)

Solution (Python):
S,T = input().split()
print(T+S)

Solution (Python):
s , t = input().split()
print(t , s , sep = "")

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

Solution (Python):
S, T = [s for s in input().split()]

print(T + S)

Solution (Python):
def main():
    S, T= [x for x in input().split()]
    print(T+S)

if __name__ == "__main__":
    main()

Solution (Python):
import sys

input = sys.stdin.readline


class AtCoder:
    def main(self):
        S, T = input().split()
        print(T+S)



if __name__ == '__main__':
    AtCoder().main()

Solution (Python):
s, t = map(str, input().split())
print(t, s, sep='')

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

Solution (Python):
S,T = input().split()
print(T+S)

Solution (Python):
a, b = input().split()


print(b+a)

Solution (Python):

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

Solution (Python):
s, t = input().split()
print(''.join([t, s]))

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
s,t=map(str,input().split())

ans=t+s
print(ans)

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
S,T = input().split()
print("".join([T,S]))

Solution (Python):
A, B = input().split()
print(B+A)

Solution (Python):
S,T = input().split()
print("".join([T, S]))

Solution (Python):
S, T = input().split()

print(T + S)

Solution (Python):
S,T=map(str,input().split())

print(T+S)

Solution (Python):
S,T= input().split()
print(T+S)

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq 
from itertools import *
import math
import random
import re
import string

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

Solution (Python):
s, t = input().split()

print(t,s,sep="")

Solution (Python):

import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = False
def main(given = sys.stdin.readline):
    input = lambda : given().rstrip()
    LMIIS = lambda : list(map(int,input().split()))
    II = lambda : int(input())
    XLMIIS = lambda x : [LMIIS() for _ in range(x)]

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





if __name__ == '__main__':
    main()

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

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
s1, s2 = input().split()
print(s2 + s1)

Solution (Python):
S, T = input().split()
print(T + S)

Solution (Python):


import sys
input = sys.stdin.readline

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

print(T+S)

Solution (Python):
s,t = input().split()

print(t+s)

Solution (Python):

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

Solution (Python):
s,t = input().split()
l = t+s
print(l)

Solution (Python):
S,T=input().split()
print(T+S)

Solution (Python):
s,t = input().split()
print(t+s)

Solution (Python):
s,t = input().split()

print(t+s)

Solution (Python):
s,t=input().split()
print(t,end="")
print(s)

Solution (Python):
s,t = input().split(' ')
print(t+s)

Solution (Python):
import sys

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

print(t + s)

Solution (Python):
a,b = map(str,input().split(' '))
print(b+a)

Solution (Python):
S,T=map(str,input().split())

print(T+S)

Solution (Python):
s, t = input().split()
print(t + s)

Solution (Python):
S, T = input().split()
print(T + S)

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

Solution (Python):
def main():
    S, T = list(input().split())

    return T + S

if __name__ == '__main__':
    print(main())

Solution (Python):
S, T = map(str, input().split())

print(T + S)

Solution (Python):
def solve():
    S, T = input().split()
    print(T + S)

if __name__ == '__main__':
    solve()

Solution (Python):


def main():
    S,T = input().split()
    print(T+S)

if __name__ == "__main__":
    main()

Solution (Python):
s, t = input().split()
print(t + s)

Solution (Python):
s,t = input().split()
print(t+s)

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
S,T=input().split()
print(T+S)

Solution (Python):
s,t = input().split()
print(t + s)

Solution (Python):
S, T = input().split() 
print(T + S)

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):

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


print(T+S)

Solution (Python):
s, t = input().split()

print(t+s)

Solution (Python):



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

Solution (Python):
import sys
input = sys.stdin.readline
s, t = [x for x in input().strip().split()]
print(t + s)

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def gcd(a,b): 
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def lcm(a,b): 
    return a/gcd(a,b)*b

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): 
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

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

if __name__=='__main__':
    main()

Solution (Python):
S, T = input().split()
print(T + S)

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

Solution (Python):
s, t = input().split()

print(t + s)

Solution (Python):
s = input().split()

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

Solution (Python):
a, b = input().split()

print(b+a)

Solution (Python):
S, T = map(str, input().split())

print(T + S)

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

Solution (Python):
s, t = input().split(' ')
print(t + s)

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
A,B = input().split(" ")

print(B+A)

Solution (Python):


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

print(T+S)

Solution (Python):
S,T = map(str,input().split())
ans = T + S
print(ans)

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
import numpy as np
import math
import bisect
import heapq


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd(a, b)


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


def main():
    S, T = get_inputs()
    print(T + S)


if __name__ == '__main__':
    main()

Solution (Python):
s, t = input().split()
ans = t + s
print(ans)

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
S,T = input().split()
ans = T+S
print(ans)

Solution (Python):

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

Solution (Python):
s, t = input().split()
print(t+s)

Solution (Python):
s,t=map(str, input().split())
print(t,s,sep='')

Solution (Python):
S, T = input().split()
ans = T + S
print(ans)

Solution (Python):
import sys

input = sys.stdin.readline

ri = lambda: int(input())
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]

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

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

Solution (Python):
a,b = map(str,input().split())
sum = b+a
print(sum)

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

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):


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

Solution (Python):
S, T = input().split()
print(T + S)

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

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

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

Solution (Python):
import sys
a,b = sys.stdin.readline().split()
print(b+a)

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(S, T):
    return T + S


def main():
    S, T = read_str_n()
    print(slv(S, T))


if __name__ == '__main__':
    main()

Solution (Python):
S,T=input().split()
print(T+S)

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):


S, T = input().split()

print(T, S, sep='')

Solution (Python):
N, M = input().split()

print(M+N)

Solution (Python):
s, t = input().split()
print(t + s)

Solution (Python):
s,t=input().split()
print(t+s)

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

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

Solution (Python):
s, t = input().split()
print(t + s)

Solution (Python):
S, T = input().split()
print(T+S)

Solution (Python):

import sys
input = sys.stdin.readline

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

Solution (Python):
s,t=input().split()
print(t+s)

Solution (Python):
S, T = (i for i in input().split())
print(T+S)