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 in Rust (1.15.1) (judge verdict: Accepted)

#![allow(unused_imports)]
#![allow(dead_code)]
use std::cmp::{max, min, Ordering};
use std::collections;
use std::io::{stdin, BufRead};
use std::fmt;

macro_rules! get
{
  ($rd:ident; V; $t:ty) => {
    scanl($rd, b'\n')
      .split_whitespace()
      .map(|w| get_inner!{w; $t})
      .collect::<Vec<_>>()
  };
  ($rd:ident; T; $($t:ty),+) => {
    {
      let s = scanl($rd, b'\n');
      let mut i = s.split_whitespace();
      ( $( get_inner!{i.next().unwrap(); $t}),+ )
    }
  };
  ($rd:ident; $t:ty) => (get_inner!{scanl($rd, b'\n'); $t});
}

macro_rules! get_inner
{
  ($src:expr; $t:ty) => {
    $src.parse::<$t>().expect("Parse Error")
  };
}

macro_rules! gets
{
  ($rd:ident; $n:expr; $($tok:tt)*) => {
    (0..)
      .take($n)
      .map(|_| get!{$rd; $($tok)*})
      .collect::<Vec<_>>()
  };
}

fn solve(rd: &mut BufRead)
{
  let (s, t) = get!(rd; T; String, String);
  println!("{}{}", t, s);
}

fn scanl(rd: &mut BufRead, delim: u8) -> String
{
  let mut buf = Vec::new();
  let _ = rd.read_until(delim, &mut buf).expect("Read Failed");
  String::from_utf8(buf)
    .expect("Invalid UTF-8 String")
    .trim_right()
    .to_string()
}

fn main()
{
  let rd = stdin();
  let mut rd = rd.lock(); // std::io::StdinLock
  solve(&mut rd);
}