jiahuimbzuai/CoQuIR huggingface dataset:
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const A = parseInt(input[0], 10);
  const B = parseInt(input[1], 10);
  
  if ((A+B)%3===0){
    console.log("Possible");
  }else if(A%3===0){
    console.log("Possible");
  }else if(B%3===0){
    console.log("Possible");
  }else{
    console.log("Impossible");
  }
  
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const A = parseInt(input[0], 10);
  const B = parseInt(input[1], 10);
  
  if ((A+B)%3===0 ||A%3===0 ||B%3===0){
    console.log("Possible");
  }else{
    console.log("Impossible");
  }  
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const t={input:require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/),n:(arg:number=0):any=>{if(arg){const a:number[]=[];for(let i=0;i<arg;i++) {a.push(t.n());}return a;}else{const a = t.input[0];t.input.shift();return Number(a);}},s:(arg:number=0):any=>{if(arg){const a:string[]=[];for(let i=0;i<arg;i++){a.push(t.s());}return a;}else{const a=t.input[0];t.input.shift();return String(a);}},c:(arg:number=0):any=>{if(arg) {const a:string[]=[];for(let i=0;i<arg;i++) {a.push(t.c());}return a;}else{let a=t.input[0].split('');const b=a[0];a.shift();if(a.length>0){t.input[0]=a.join('');}else{t.input.shift();}return String(b);}},o: (...arg)=>{console.log(...arg);},abs:(a)=>{return Math.abs(a);},min:(...a)=>{return Math.min(...a);},max:(...a)=>{return Math.max(...a);},floor:(a)=>{return Math.floor(a);},asc:(ar:number[])=>{return ar.sort((a,b)=>{return a-b});},desc:(ar:number[])=>{ return ar.sort((a,b)=>{return b-a});},sw:(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length;i+=2){if(eval(a+op+arr[i]))return arr[i+1]}return arr[arr.length-1];}}
const main = ()=>{
  let [a,b] = t.n(2)
  t.o(a%3==0||b%3==0||(a+b)%3==0?'Possible':'Impossible')
}
main()
//  [typescript]
"use strict";
const Main = (input) =>{
   let xs = input.trim().split(' ').map(v=>parseInt(v,10));
   let num = xs[0]+xs[1];
   if(num%3==0){
     console.log('Possible');
   }else{
     console.log('Impossible');
   }
}
Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const A = parseInt(input[0], 10);
  const B = parseInt(input[1], 10);
  
  if ((A+B)%3===0){
    console.log("Possible");
  }else if(A|B%3===0){
    console.log("Possible");
  }else{
    console.log("Impossible");
  }
  
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]



a = input().replace(',', ' ')
print(a)
//  [python]
s = list(map(str,input().split(",")))
print(" ".join(s))
//  [python]
phrase = input()

if len(phrase) > 19:
    print("error")
else:
    print(phrase.replace(","," "))
//  [python]
a, b, c = input().split(,)
print(a, b, c)
//  [python]
x, y ,z = input().split(,)
print(x, y, z)
//  [python]
    string = input()

    ans = string.replace(',', ' ')
    print(ans)
//  [java]
import java.io.*;

public class Main {
  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
    String s = br.readLine();
    
    System.out.println(s.replaceAll(",", " "));
  }
}
//  [java]
import java.io.*;
import java.util.*;

public class Main{
    
    public static void main(String[] args) throws IOException {
        String s = in.next();
        String ans = s.substring(0, 5)+" "+s.substring(6, 13)+" "+s.substring(14);
        println(ans);
        
        in.close();
        out.close();
    }

    static int MIN = Integer.MIN_VALUE;
    static int MAX = Integer.MAX_VALUE;
    static Reader in = new Reader();
    static PrintWriter out = new PrintWriter(System.out);
    static void read(int arr[], int N) throws IOException{ for(int i = 0; i < N; i++){ arr[i] = in.nextInt(); } }
    static void read(long arr[], int N) throws IOException{ for(int i = 0; i < N; i++){ arr[i] = in.nextLong(); } }
    static void read(String arr[], int N) throws IOException{ for(int i = 0; i < N; i++){ arr[i] = in.next(); } }
    static void print(Object O){ out.print(O); }
    static void println(Object O){ out.println(O); }
    static void print(int arr[]){ for(int i = 0; i < arr.length; i++){ print(arr[i]+" "); } println(""); }
    static void print(int arr[][]){ for(int i = 0; i < arr.length; i++){ print(arr[i]); } }
    static void debug(Object O){ System.out.println(O); }
}

class Reader {
    BufferedReader reader;
    StringTokenizer tokenizer;

    Reader() {
        reader = new BufferedReader(new InputStreamReader(System.in));
        tokenizer = new StringTokenizer("");
    }

    String next() throws IOException {
        while (!tokenizer.hasMoreTokens() ) { 
            tokenizer = new StringTokenizer(reader.readLine()); 
        }
        return tokenizer.nextToken();
    }

    int nextInt() throws IOException { 
        return Integer.parseInt(next()); 
    }
    
    double nextDouble() throws IOException { 
        return Double.parseDouble(next());
    }
    
    long nextLong() throws IOException { 
        return Long.parseLong(next()); 
    }
    
    String nextLine() throws IOException { 
        return reader.readLine(); 
    }
    
    void close() throws IOException { 
        reader.close(); 
    }
}
//  [java]
import java.util.*;

public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    String s = sc.next();
    System.out.println(s.replace(",", " ");
  }
}
//  [java]
import java.util.*;

public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    String s[] = sc.next().split(",");
    System.out.println(s.join(" "));
  }
}
//  [java]
import java.util.Scanner;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int s=sc.nextInt();
    int ans=0;
    for(int x=0;x<k+1;x++){
      for(int y=0;y<k+1;y++){
        for(int z=0;z<k+1;z++){
			if(x+y+z==s){
              ans++;
            }
        }
      }
    }
      System.out.println(ans);
    }
  }
//  [cpp]
#include <cstdio>

int main() {
        int n = 19;
        while (n-->0) {
                char c = getchar();
                if (c==',') {
                        putchar(' ');
                } else {
                        putchar(c);
                }
        }
        return 0;
}
//  [cpp]
#include <cstdio>



int main() {
    char ch;
    for (int i = 1; i <= 5; i++) {
        ch = fgetc(stdin);
        fputc(ch, stdout);
    }
    ch = fgetc(stdin);
    char space = ' ';
    fputc(space, stdout);
    for (int i = 1; i <= 7; i++) {
        ch = fgetc(stdin);
        fputc(ch, stdout);
    }
    ch = fgetc(stdin);
    space = ' ';
    fputc(space, stdout);
    for (int i = 1; i <= 5; i++) {
        ch = fgetc(stdin);
        fputc(ch, stdout);
    }
    return 0;
}
//  [cpp]
#include <cstdio>

char s[20];

int main(){
	scanf("%s", s);
	for(int i=0; s[i]!='\0'; ++i)
		if(s[i] == ',')
			s[i] = ' ';
	printf("%s\n", s);
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
int main() {
  
  string s;
 
  cin >> s;
  
  s[5]=’ ’,s[13]=’ ’;
  
  for (int i = 0; i < s.size(); i++) {
      if ( s.at(i) == ',' ) {
        s.at(i) = ' ';
      }  
  }
  
  cout << s << endl;
}
#include <bits/stdc++.h>
using namespace std;
 
int main() {
  
  string s;
 
  cin >> s;
  
  s[5]=' ',s[13]=' ';
  
  for (int i = 0; i < s.size(); i++) {
      if ( s.at(i) == ',' ) {
        s.at(i) = ' ';
      }  
  }
  
  cout << s << endl;
}
提出情報
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
int main() {
  
  string s;
 
  cin >> s;
  
  s[5]=’ ’,s[13]=’ ’;
  
  for (int i = 0; i < s.size(); i++) {
      if ( s.at(i) == ',' ) {
        s.at(i) = ' ';
      }  
  }
  
  cout << s << endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
int main() {
  
  string s;

  cin >> s;
  
  for (int i = 0; i < s.size(); i++) {
      if ( s.at(i) == "," ) {
        s.at(i) = " ";
      }  
  }
  
  cout << s << endl;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main()
{
 char a[20];
 gets(a);
 a[5]=' ';
a[13]=' ';
puts(a);
    return 0;
}
//  [c]
#include<stdio.h>

int main()
{
	char a[25];
	scanf("%s", a);
	for(int i = 0; i < 5; i++)
		printf("%c", a[i]);
	printf(" ");
	
	for(int i = 6; i < 13; i++)
		printf("%c", a[i]);
	printf(" ");
	
	for(int i = 14; i < 19; i++)
		printf("%c", a[i]);
	printf(" ");
	
	return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>
int main()
{
	int a,b,i;
	char c[20];
	scanf("%s",c);
	for(i=0;i<5;i++)
	 	printf("%c",c[i]);
		printf(" ");
	for(i=6;i<13;i++)
	 	printf("%c",c[i]);
		printf(" ");
	for(i=14;i<19;i++)
	 	printf("%c",c[i]);
		printf("\n"); 		 
	return 0;
}
//  [c]
#include<iostream>
using namespace std;
int main(){
  string a, b, c;
  cout << a << " " << b << " " << c;
}
//  [c]
#include <stdio.h>
int main(){
  char a[10]={0}, b[10]={0}, c[10]={0};
  scanf("%s,%s,%s", a, b, c);
  printf("%s %s %s", a, b, c);
  return 0;
}
//  [c]
#include <stdio.h>

int main (){
	
	char str[30];
	scanf ("%[^\n]", &str);
	
	for (int i = 0; i < 29; i++){
		if (i==5 || i ==13){
			printf(" ");
			continue;
		}
		
		printf ("%c", str[i]);
	}
	
	
	
	return 0;
}
//  [javascript]
"use strict";

function main(input){
  const args = input.trim().split(',');
  console.log(args.join(" "));
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
console.log(require("fs").readFileSync("/dev/stdin", "utf8").split(",").join(" "));
//  [javascript]
'use strict'

function main(s) {

  s = s.split('\n')[0];

  const ans = s.replace(/,/g, ' ');

  console.log(ans);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input){
  const s = input.split(,).join(" ");
  console.log(s);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input){
  console.log(input.join(" "));
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict";

function main(input) {
    input = input.split(' ');
  	const K = parseInt(input[0]);
  	const S = parseInt(input[1]);
    let C = []
    
    if(S < 0 || S > 3 * K) {
        //console.log("error")
    }
    else if(K < 2 || K > 2500) {
        //console.log("error")
    }
  	else {
    
      if(S === 3 * K) {
          C.push([K,K,K])
      } else {
          for(let i = 0; i <= K; i++) {
              for(let j = 0; j <= K; j++) {
                  for(let k = 0; k <= K; k++) {
                      const s = i+j+k
                      if(s<=3 * K && i+j+k===S) {
                          C.push([i,j,k])
                          k=K// break the third loop
                          j=K// break the second loop
                      }
                  }
              }
          }
      }
    }
    
    console.log(C.length)
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
	"strings"
)

// 以下の問題
// https://atcoder.jp/contests/abc051/tasks/abc051_a

func main() {
	var s string
	fmt.Scan(&s)
	fmt.Println(strings.Replace(s,","," ", -1))
}
//  [go]
package main

import (
  "fmt"
  "strings"
)

func main() {
  var s string; fmt.Scan(&s)
  s = strings.Replace(s, ",", " ", -1)
  fmt.Println(s)
}
//  [go]
package main

import "fmt"

func main() {
	var k, s, ans int
	fmt.Scan(&k, &s)
	for x := 0; x <= k; x++ {
		for y := 0; y <= k; y++ {
			z := s - x - y
			if 0 <= z && z <= k {
				ans++
			}
		}
	}
	fmt.Println(ans)
}
//  [go]
package main

import (
  "fmt"
  "strings"
)

func main() {
  var s string; fmt.Scan(&s)
  s = strings.ReplaceAll(s, ",", " ")
  fmt.Println(s)
}
//  [ruby]
str = gets.chomp.split(',')
puts str.join(' ')
//  [ruby]
a, b, c = gets.split(",")
puts "#{a} #{b} #{c}"
//  [ruby]
puts gets.tr(", ", " ")
//  [ruby]
s = gets.chomp.gsub(/,/, ' ')
p s
//  [ruby]
(0..K).each do |i|
  (0..K).each do |j|
      count += 1 if i + j <= S && S - i - j <= K
    end
  end
end
puts count
//  [ruby]
list = gets.chomp.split(' ')
k = list[0].to_i
s = list[1].to_i


count = 0
for l in 0..k do
    x = l
  	if x > s then
      break
    end
 
	for m in 0..k do
  		y = m
    	subsum = x + y
    	z = s - subsum
    	if subsum > s then
      		break
    	end
    	if z >= 0 && z <= k then
      		count += 1
    	end
  	end
end
p count
//  [rust]
#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use std::cmp::*;
use std::collections::*;
use std::mem::*;

fn main() {
    let (r, w, e) = (std::io::stdin(), std::io::stdout(), std::io::stderr());
    let mut io = IO::new(r.lock(), w.lock(), e.lock());
    assert_eq!(!0usize, std::usize::MAX); //🙊
    let mut s = io.chars();

    for i in 0..19 {
        match i {
            5 | 13 => io.write(" "),
            _ => io.write(s[i]),
        }
    }
}

static MOD: i64 = 1000000007;
static INF: i64 = std::i64::MAX >> 1;
// IO
use std::io::*;
struct IO<R: Read, W: Write, E: Write> {
    Read: R,
    Write: BufWriter<W>,
    Error: BufWriter<E>,
}
impl<R: Read, W: Write, E: Write> IO<R, W, E> {
    fn new(r: R, w: W, e: E) -> IO<R, W, E> {
        IO {
            Read: r,
            Write: BufWriter::new(w),
            Error: BufWriter::new(e),
        }
    }
    fn read<T>(&mut self) -> T
    where
        T: std::str::FromStr,
    {
        let next: String = self
            .Read
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();
        next.parse().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
    fn chari(&mut self) -> Vec<i64> {
        self.chars()
            .iter()
            .map(|&c| (c as u8 - b'0') as i64)
            .collect::<Vec<i64>>()
    }
    fn readn<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect::<Vec<_>>()
    }
    fn readmat<T: std::str::FromStr>(&mut self, n: usize, m: usize) -> Vec<Vec<T>> {
        (0..n).map(|_| self.readn(m)).collect()
    }
    fn write<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
    }
    fn writeln<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
        self.Write.write(b"\n");
    }
    fn debug<S: std::fmt::Debug>(&mut self, val: S) {
        writeln!(self.Error, "(debug) {:?}", &val);
    }
    fn debug2<S: std::fmt::Debug, T: std::fmt::Debug>(&mut self, val1: S, val2: T) {
        writeln!(self.Error, "(debug2) {:?} -> {:?}", val1, val2);
    }
    fn debug3<S: std::fmt::Debug, T: std::fmt::Debug, U: std::fmt::Debug>(
        &mut self,
        val1: S,
        val2: T,
        val3: U,
    ) {
        writeln!(
            self.Error,
            "(debug3) {:?} -> {:?} -> {:?}",
            val1, val2, val3
        );
    }
}
//  [rust]
use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.trim().split(',');
	let mut v:Vec<String> = Vec::new();
	for i in iter {
		v.push((*i).to_string());
	}
	let s = format!("{} {} {}", v[0], v[1], v[2]);
	println!("{}", s);
}
//  [rust]
fn read1<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn readn<T: std::str::FromStr>(delimiter: &str) -> Vec<T> {
    let s = read1::<String>();
    s.split(delimiter).map(|e| e.parse().ok().unwrap()).collect::<Vec<T>>()
}

fn main() {
    let s = readn::<String>(",");
    println!("{} {} {}", s[0], s[1], s[2]);
}
//  [rust]
use proconio::input;

// use std::cmp::*;
// use std::collections::*;
// use proconio::marker::Chars;

fn main() {
    input! {
        // s: String
        // n: isize
    }
}
//  [rust]
use std::io::{stdout, BufWriter, Write};

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        k: usize,
        s: usize,
    }
    let out = stdout();
    let mut out = BufWriter::new(out.lock());
    let mut ans = 0;
    for i in 0..k + 1 {
        for j in 0..k + 1 {
            for l in 0..k + 1 {
                if i + j + l == s {
                    ans += 1;
                }
            }
        }
    }
    writeln!(out, "{}", ans);
}
//  [rust]
extern crate regex;
use regex::Regex;
use std::io::stdin;

fn main() {
    let mut s = String::new();
    stdin().read_line(&mut s).ok();
    let re = Regex::new(r"(\w+),(\w+),(\w+)").unwrap();
    let ans = re.captures(&s).unwrap();
    println!("{} {} {}", &ans[1], &ans[2], &ans[3]);
}
//  [swift]
print(readLine()!.characters.split(",").map{String($0)}.joinWithSeparator(" "))
//  [swift]
extension String: CollectionType{}
let a: [String] = readLine()!.split(",")
print(a[0],a[1],a[2])
//  [swift]
extension String: CollectionType{}
let a: [String] = readLine()!.split(",")
print(a[0],a[1],a[2], separator: " ")
//  [swift]
import Foundation

let input_line: String = readLine()!
let strings: [String] = input_line.components(separatedBy: " ")

let K = (Int)(strings[0])!
let S = (Int)(strings[1])!

var counter = 0

for i in 0...K {
    for j in 0...K {
        for k in 0...K {
            if (i + j + k) == S {
                counter += 1
            }
        }
    }
}

print(counter)
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  let a=sin()
  out(a.replace(/,/g, ' '))
}
main()
//  [typescript]
var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var inputLines: string[] = input.trim().split("\n");
var parts = inputLines[0].split(" ");

var s = parts[0].replace(/,/g, " ");
console.log(s);
//  [typescript]
import * as fs from "fs"

function Main(input: string) {

  const p = input.split("\n")[0]
  const ans = p.replace(/,/g, " ")
  console.log(ans)
}


fs.readFile('/dev/stdin', (err, data) => {
  if (err) {
    Main(fs.readFileSync('./input.txt', 'utf8'))
    return null
  }
  Main(data.toString())
  return null
})
//  [typescript]
const main = (input) => {
  input = input.split(',');
  const str1 = input[0];
  const str2 = input[1];
  const str3 = input[2];
  
  const strResult = str1+str2+str3;
  const result = strResult.replace(',',' ');
  
  console.log(result);
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input) => {
  input.input.split(',');
  const str1 = input[0];
  const str2 = input[1];
  const str3 = input[2];
  
  const strResult = str1+str2+str3;
  const result = strResult.replace(',',' ');
  
  console.log(result);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
a,b,c = sorted(map(int, input().split()))

if a + b == c :
	print('Yes')
else:
	print('No')
//  [python]
a,b,c=sorted(map(int,input().split()))
print("Yes" if a+b==c else "No")
//  [python]
a=list(map(int,input().split()))
a.sort()
if sum(a)==a[-1]*2:
  print("Yes")
else:
  print("No")
//  [python]
if a + b  = c:
    print('Yes')
elif a + c = b:
    print('Yes')
elif b + c = a:
    print('Yes')
else:
    print('No')
//  [python]
x,y,z =sorted(map(int,input().split()))
print("Yes" if x+y==z "No")
//  [python]
a,b,c = map(int, input().split())

if (a+b+c) % 3 == 0:
  print("Yes")
else:
  print("No")
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String x = br.readLine();
		String[] cut = x.split(" ");
		String h = "No";

		int a = Integer.parseInt(cut[0]);
		int b = Integer.parseInt(cut[1]);
		int c = Integer.parseInt(cut[2]);

		if (a + b == c || a + c == b || b + c == a) {
			h = "Yes";
		}

		System.out.println(h);
	}
}
//  [java]
import java.io.*;

public class Main
{
    public static void main (String[] args) throws IOException
    {
        InputStreamReader is = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(is);

        String str1 = br.readLine();
        String[] str2 = str1.split(" ", 0);
        int i[] = new int[3];
        String result;

        for(int j=0; j<3; j++) {
        	i[j] = Integer.parseInt(str2[j]);
        	//System.out.println(i[j]);
        }

       	if(i[0] == i[1]+i[2]) { result = "Yes"; }
       	else if(i[1] == i[2]+i[0]) { result = "Yes"; }
       	else if(i[2] == i[0]+i[1]) { result = "Yes"; }
       	else { result = "No"; }

       	System.out.println(result);
    }
}
//  [java]
import java.util.Scanner;

public class Main {
	public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int c = sc.nextInt();
		c = Math.min(a,b) + c;
		if(c == a || c == b) {
			System.out.println("Yes");
		}
		else {
			System.out.println("No");
		}
	}
}
//  [java]
import java.util.Scanner;
import java.util.Arrays;

public class Main {
	public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		int[] values = {sc.nextInt(),sc.nextInt(),sc.nextInt()};
		Arrays.sort(values);
		if(values[0]+values[1] == values[2]) {
			System.out.println("YES");
		}
		else {
			System.out.println("NO");
		}
	}
}
//  [java]

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int A, B, C;
        A = input.nextInt();
        B = input.nextInt();
        C = input.nextInt();
        if (A + C == B || C + B == A || A + B == C) {
            System.out.println("yes");
        } else {
            System.out.println("No");
        }

    }
}
//  [cpp]
#include<cstdio>
int main()
{
	int a,b,c,s,max;
	scanf("%d%d%d",&a,&b,&c);
	s=a+b+c;
	max=a>b?a:b;
	max=max>c?max:c;
	if(2*max==s) printf("Yes\n");
	else printf("No\n");
	return 0;
}
//  [cpp]
#include <stdio.h>

int main(){
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    if(a+b==c||b+c==a||c+a==b){
        printf("Yes\n");
    }else{
        printf("No\n");
    }
}
//  [cpp]
#include<cstdio>
#include<cmath>

const int N = 100000;
char a[N];
char b[N];
int main()
{
	int a,b,c;
	scanf("%d%d%d",&a,&b,&c);
	if(a == b+c || b == a+c || c == a+b)
	printf("Yes\n");
	else
	printf("No\n");
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
#define debug(x) cout << '>' << #x << ':' << x << endl;
#define ll long long

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	ll w, h, n;
	cin >> w >> h >> n;
	ll lw = 0, lh = 0;
	ll x[n], y[n], a[n];
	for (int i = 0; i < n; i++) {
		cin >> x[i] >> y[i] >> a[i];

		if (a[i] == 1) {
			lw = max(x[i], lw);
		} else if (a[i] == 2) {
			w = min(w, x[i]);
		} else if (a[i] == 3) {
			lh = max(y[i], lh);
		} else if (a[i] == 4){
			h = min(h, y[i]);
		}
	}
	if (w - lw <=0 || h - lh <= 0) return cout << 0 << endl,0;
	cout <<  (ll) (w - lw) * (h - lh);
	return 0;

}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
vector<int>vec;
set<int>st;
int main()
{
    int i,j,n,t,a,b,c;
    string s,s1,s2;
    cin>>a>>b>>c;
    if(a+b==c||a+c==b||b+c==a)
        cout"Yes"<<"\n";
    else
        cout<<"No"<<"\n";
    
    

return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
#define pb push_back
#define rsz resize
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
using pi = pair<int,int>;
#define f first
#define s second
#define mp make_pair
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
void setIO(string name = "a") {
    ios_base::sync_with_stdio(0); cin.tie(0);
    freopen((name+".in").c_str(), "r", stdin);
    freopen((name+".out").c_str(), "w", stdout);
}

int main() {
    //setIO();
    int a, b, c; cin >> a >> b >> c;
    if ((a + b + c) % 3 == 0) {
        cout << "Yes" << "\n";
    } else {
        cout << "No" << "\n";
    }
}
//  [c]
#include<stdio.h>

int main(){
int a,b,c;
  scanf("%d %d %d",&a,&b,&c);
  if(a > b || a > c){
    if(a == b + c){
      printf("Yes");
    }
    else{
    printf("No");
  }
  }
  else if(b > a || b > c){
    if(b == a + c){
      printf("Yes");
    }
    else{
    printf("No");
  }
  }
  else if(c > a || c > a){
    if(c == a + b){
      printf("Yes");
    }
    else{
    printf("No");
  }
  }
  else{
    printf("No");
  }
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
#define BIG 2000000007
 
#define MOD 1000000007
typedef unsigned long long ull;
typedef   signed long long sll;
 
typedef struct {
	ull above;
	ull below;
	int index;
} hw;
 
#define N_MAX 100000
#define M_MAX 100000
 
ull n, m, k;
ull h, w;
// ull a[N_MAX];
// ull b[N_MAX];
// ull dp[N_MAX][M_MAX + 1];
char s[N_MAX + 1];
char t[N_MAX + 1];
 
void swap_adj(ull *a, ull *b){
	ull tmp = *b;
	*b = *a;
	*a = tmp;
	return;
}
 
int comp(const void *a, const void *b){
	if (*(ull*)a > *(ull*)b) {
		return -1;
	} else if (*(ull*)a < *(ull*)b) {
		return +1;
	} else {
		return 0;
	}
}
 
ull divide(ull a, ull b){
	ull x = MOD - 2;
	ull ans = 1;
	while (x) {
		if (x & 1) ans = (ans * b) % MOD;
		b = (b * b) % MOD;
		x /= 2;
	}
	return (a * ans) % MOD;
}
 
int digits(ull x){
	int i = 1;
	while (x >= 10) {
		x /= 10;
		i++;
	}
	return i;
}
 
int min(ull x, ull y){
	return (x < y) ? x : y;
}
 
ull gcd(ull x, ull y){
	if (x < y) {
		return gcd(y, x);
	} else if (y == 0) {
		return x;
	} else {
		return gcd(y, x % y);
	}
}
 
ull bitpow(ull a, ull x){
	ull result = 1;
	while (x) {
		if (x & 1) {
			result *= a;
			result %= MOD;
		}
		x /= 2;
		a = (a * a) % MOD;
	}
	return result;
}
 
ull solve(){
	int i, j;
	const size_t len = strlen(t);
 
	for (i = 0; i < len; i++) {
		if (t[i] != s[0]) continue;
		for (j = 1; i + (k - 1) * j <= len - 1; j++) {
			int seeki;
			for (seeki = 1; seeki < k; seeki++) {
				if (t[i + seeki * j] != s[seeki]) break;
			}
			if (seeki == k) return 1;
		}
	}
 
	return 0;
}
 
int main(void){
	int i, j, k;
	int a[3];
	int x = 0;
 
	scanf("%d%d%d", &i, &j, &k);

	if (i + j == k || j + k == i || k + i == j) {
		puts("Yes");
	} else {
		puts("No");
	}

	// solve();
 
	return 0;
}
//  [c]
#include<stdio.h>
int main(){
  int a,b,c,min,mid,max;
  scanf("%d%d%d",&a,&b,&c);
  min=(a<b)?a:b;
  min=(min<c)?min:c;
  max=(a>b)?a:b;
  max=(max>c)?max:c;
  mid=a+b+c-min-max;
  if(min+mid==max){
    printf("Yes");
  }
  else{
    printf("No");
  }
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ll long long
#define fr(i,n,m) for(ll i=n;i<m;i++)
int main()
{
    ll a,b,c;
    scanf("%lli %lli %lli",&a,&b,&c);
    if ((a+b+c)%2 == 0)
    {
        puts("Yes");
    } else {
        puts("No");
    }
    return 0;
}
//  [c]
#include<stdio.h>
int main(){
  int a,b,c;
  scanf("%d%d%d\n",&a,&b,&c);
  if((a+b)==c || (c+b)==a || (a+c)==b) printf("YES\n");
  else printf("NO\n");
  return 0;
}
//  [c]
#include<stdio.h>
int main(){
  int a,b,c,flag=0;
 // int A;
  scanf("%d%d%d\n",&a,&b,&c);
  if(a==(b+c) || b==(a+c) || c==(b+a)) printf("YES\n");
  else printf("NO\n");
  return 0;
}
//  [javascript]
'use strict';

function Main(input) {
    const tmp = input.split('\n')[0];
    const a = parseInt(tmp.split(' ')[0], 10);
    const b = parseInt(tmp.split(' ')[1], 10);
    const c = parseInt(tmp.split(' ')[2], 10);

    if (a + b == c || a + c == b || b + c == a) {
        console.log("Yes");
    } else {
        console.log("No");
    }
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main (s) {
    s=s.split(" ");
	for(var i=0;i<3;i++)s[i]=parseInt(s[i]);
	var mx=Math.max(s[0],s[1],s[2]);
	var sum=s[0]+s[1]+s[2];
	console.log((mx*2==sum)?"Yes":"No");
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
'use strict'

const main = input => {
	const args = input.trim().split(' ')
	const a = parseInt(args[0], 10)
	const b = parseInt(args[1], 10)
	const c = parseInt(args[2], 10)
	if (a === b + c) console.log('Yes')
	else if (a + b === c) console.log('Yes')
	else if (a + c === b) console.log('Yes')
	else console.log('No')
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function main(input) {
  input = input.trim();
  const [a,b,c] = input.split(" ").map(Number);
  console.log((a+b+c)%2==0?'Yes':'No');
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input=input.split("\n");
　var N=input[0].trim().split(" ");
  [0,1,2].forEach(e=>{
    N[e]-=0;
  });
  N.sort();
  console.log(N[0]+N[1]===N[2]?"Yes":"No");
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";
 
function main(arg){
  const input = arg.trim().split(' ');
  const s = input[1][0];
  console.log("A" + s + "C")
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

func getInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func getString() string {
	sc.Scan()
	return sc.Text()
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	sc.Split(bufio.ScanWords)

	a := getInt()
	b := getInt()
	c := getInt()

	ma := max(a, max(b, c))
	su := 0
	if ma == a {
		su = b + c
	} else if ma == b {
		su = a + c
	} else {
		su = a + b
	}

	if ma == su {
		out("Yes")
	} else {
		out("No")
	}

}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)

	if a+b == c || a+c == b || b+c == a {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"fmt"
	"sort"
)

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)
	ints := []int{a, b, c}
	sort.Ints(ints)
	if ints[0]+ints[1] == ints[2] {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)

	if (a+b) == c || (b+c) == a || (c+a) == b {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
//  [ruby]
a,b,c=gets.split.map &:to_i;puts a==b+c||b==c+a||c ==a+b ?:Yes: :No
//  [ruby]
x = gets.split.map(&:to_i)
y = x.sort!.pop
puts x.inject(:+)==y ? "Yes" : "No"
//  [ruby]
a, b, c = gets.split.map(&:to_i) 

if a == b + c
  puts "Yes"
elsif b == a + c
  puts "Yes"
elsif c == a + b
  puts "Yes"
else
  puts "No"
end
//  [ruby]
a=gets.split.map(&:to_i)
puts a.find_index(a.sum/3.to_f) ? "Yes" : "No"
//  [ruby]
a=gets.split.map(&:to_i)
puts a.find_index(a.sum/3) ? "Yes" : "No"
//  [ruby]
x = gets.chomp.split(" ").map(&:to_i)
all = x.inject(:+)
if all % 2 == 0
    puts "Yes"
else
    puts "No"
end
//  [rust]
use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let a = v[0];
	let b = v[1];
	let c = v[2];
	if a+b == c || a+c == b || b+c == a {
		println!("Yes");
	}else{
		println!("No");
	}
}
//  [rust]
use std::io::stdin;

fn main() {
    let mut s = String::new();
    stdin().read_line(&mut s).ok();
    let a: Vec<usize> = s
        .split_whitespace()
        .map(|e| e.parse::<usize>().unwrap())
        .collect();
    let max = *a.iter().max().unwrap();
    let others = a.iter().sum::<usize>() - max;

    println!("{}", if max == others { "Yes" } else { "No" });
}
//  [rust]
//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 より
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

//

use std::io::Write;

fn run() {
    input! {
        a: [u32; 3],
    }
    let s: u32 = a.iter().sum();
    for i in 0..3 {
        if s - a[i] == a[i] {
            println!("Yes");
            return;
        }
    }
    println!("No");
}

fn main() {
    run();
}
//  [rust]
use proconio::input;

// use std::cmp::*;
// use std::collections::*;
// use proconio::marker::Chars;

fn main() {
    input! {
        // s: String
        // n: isize
        a:i64,
        b:i64,
        c:i64,
    }
    let mut ans = 0;
    ans += a%2;
    ans += b%2;
    ans += c%2;
    println!("{}", if ans%2==0 {"Yes"}else{"No"});
}
//  [rust]
use whiteread::parse_line;

fn main() {
    let (a, b, c): (u64, u64, u64) = parse_line().unwrap();
    if (a+b+c) % 3 == 0 {
        println!("Yes");
    } else {
        println!("No");
    }
}
//  [rust]
use std::io::stdin;

fn main() {
    let mut s = String::new();
    stdin().read_line(&mut s).ok();
    let a = s.split_whitespace().map(|e| e.parse::<usize>().unwrap());
    let max = a.clone().max().unwrap();
    let others = a.sum::<usize>() - max;

    println!("{}", if max == others { "Yes" } else { "No" });
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!},m=i.maxElement()!;print(m==i[0]+i[1]+i[2]-m ?"Yes":"No")
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
let a = Int(split[0])!
let b = Int(split[1])!
let c = Int(split[2])!

if (a+b==c || a+c==b || b+c==a){
    print("Yes")
}else{
    print("No")
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!},m=i.maxElement();print(m==i[0]+i[1]+i[2]-m ?"Yes":"No")
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!},m=i.maxElement();print(m==i[0]+i[1]+1[2]-m ?"Yes":"No")
//  [swift]
var a = 1;
//  [typescript]
import * as fs from "fs";
 
let input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
var bags = input[0].split(" ").map(x => parseInt(x));
var a = bags[0]
var b = bags[1]
var c = bags[2]
var result = "No"

if (a == b + c || b == c + a || c == a + b) { 
result = "Yes"
};

console.log(result);
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  let [a,b,c]=nrin(3)
  out(a+b==c||a+c==b||b+c==a?'Yes':'No')
}
main()
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const a = parseInt(input[0], 10);
  const b = parseInt(input[1], 10);
  const c = parseInt(input[2], 10);
  
  if (a+b===c || a+c===b || b+c===a) {
    console.log('Yes');
  }else{
    console.log('No');
  }
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const packs = input[0].map(Number);

  packs.sort();

  return packs[0] + packs[1] === packs[2] ? "Yes" : "No";
};

console.log(main(read()));
//  [typescript]
"use strict";
const Main = (input) =>{
   let xs = input.trim().split(' ').map(v=>parseInt(v,10));
   let num = xs[0]+xs[1]+xs[2];
   if(num%3==0){
      console.log('Yes');
   }else{
      console.log('No');
   }
}
Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [typescript]
import * as fs from "fs";
 
let input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
var bags = input[0].split(" ").map(x => parseInt(x));
var a = bags[0]
var b = bags[1]
var c = bags[2]
var result = "No"

if (a == b + c && b == c + a && c == a + b) { 
result = "Yes"
};

console.log(result);
//  [python]
nums = input().split()
N = int(nums[0])
L = int(nums[1])


#繰り返しの要素入力
count = 0
list = []

while count < N:
    list.append(input())
    count += 1

s_list = sorted(list)
print(''.join(s_list))
//  [python]
n,m = map(int , input().split())
li=[]
for i in range(n):
 li.append(input())
li=sorted(li)
st=''
for e in li:
    st=st+e
print(st)
//  [python]
N,L=map(int,input().split())
S=[]
for i in range(N):
  S.append(input())

S=sorted(S)
for i in range(N):
  print(S[i],end="")
//  [python]
n,l = map(int,input().split())
a = []
for i in range(n):
  a.append(input())
  
a.sort()
for i in a:
  print(i)
//  [python]
println(join(sort!(readlines()[2:end])))
//  [python]
n, l = map(int, input().split())
A = sorted([input() for _ in range(l)])
print("".join(A))
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;




public class Main{
	static class MyScanner {
	    BufferedReader br;
	    StringTokenizer st;

	    public MyScanner() {
	       br = new BufferedReader(new InputStreamReader(System.in));
	    }

	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try {
	                st = new StringTokenizer(br.readLine());
	            } catch (IOException e) {
	                e.printStackTrace();
	            }
	        }
	        return st.nextToken();
	    } 

	    int nextInt() { return Integer.parseInt(next());}

	    long nextLong() {return Long.parseLong(next());}

	    double nextDouble() {return Double.parseDouble(next());}

	    String nextLine(){
	        String str = "";
		  try {
		     str = br.readLine();
		  } catch (IOException e) {
		     e.printStackTrace();
		  }
		  return str;
	    }
	}
		
	
		 public static void main(String[] args) throws IOException {
			 	PrintWriter out = new PrintWriter(System.out);
			    MyScanner sc = new MyScanner();
			 	Main solver = new Main();
				solver.solve(out, sc);
				out.flush();
				out.close();
			
		 }
	
		
		 
		 
		
 		void solve(PrintWriter out, MyScanner sc) throws IOException{	
 			
 			int n = sc.nextInt();
 			int l = sc.nextInt();
 			
 			String[] s = new String[n];
 			for(int i = 0; i < n ; ++i) s[i] = sc.nextLine();
 			
 			Arrays.sort(s);
 			for(String ss : s) out.print(ss);
 					
 			
 			
 			
 		
 		}
 		
 		

 	
		
	
			
		
		
		
		
		
		
		
		
	
	
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        String[] firstLine = input.readLine().split(" ");
        int N = Integer.parseInt(firstLine[0]);
        int L = Integer.parseInt(firstLine[1]);

        String[] strings = new String[N];

        for (int i = 0; i < N; i++) {
            strings[i] = input.readLine();
        }

        Arrays.sort(strings);

        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < N; i++) {
            builder.append(strings[i]);
        }
        System.out.println(builder.toString());
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws Exception {
        // Your code here!
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] nl = br.readLine().split(" ");
        int n = Integer.parseInt(nl[0]);
        int l = Integer.parseInt(nl[1]);
        String[] s = new String[n];
        
        for (int i = 0; i < n; i++) {
            s[i] = br.readLine();
        }
        Arrays.sort(s);
        String ans = String.join("", s);
        System.out.println(ans);
    }
}
//  [java]
import java.util.*;

// Iroha's Strings
public class Main {
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // String params = scanner.nextLine();
        int numStrings = scanner.nextInt();
        int stringLen = scanner.nextInt(); 
        scanner.nextLine();
        // scanner.next() reads up until \n it won't consume it. You need next Line to pusition the 
        // System.out.println(scanner.nextLine()); // handle of first line \n that is

        List<String> strings = new ArrayList<>();
        for (int i=0; i<numStrings; i++) {
            String curr = scanner.nextLine();
            // System.out.println("curr" + curr);
            strings.add(curr);
        }
        // I have the strings now simply sort them and concatenate
        Collections.sort(strings);
        StringBuilder sb = new StringBuilder();
        for (String s : strings) {
            // System.out.printf("String:%s, numStrings:%d, stringLen:%d %n", s, numStrings, stringLen);
            sb.append(s);
        }                       
        scanner.close();            
        // System.out.println(sb.toString());
    }
    
}
//  [java]
import java.util.*;

// Iroha's Strings
public class B {
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // String params = scanner.nextLine();
        int numStrings = scanner.nextInt();
        int stringLen = scanner.nextInt(); 
        scanner.nextLine();
        // scanner.next() reads up until \n it won't consume it. You need next Line to pusition the 
        // System.out.println(scanner.nextLine()); // handle of first line \n that is

        List<String> strings = new ArrayList<>();
        for (int i=0; i<numStrings; i++) {
            String curr = scanner.nextLine();
            // System.out.println("curr" + curr);
            strings.add(curr);
        }
        // I have the strings now simply sort them and concatenate
        Collections.sort(strings);
        StringBuilder sb = new StringBuilder();
        for (String s : strings) {
            // System.out.printf("String:%s, numStrings:%d, stringLen:%d %n", s, numStrings, stringLen);
            sb.append(s);
        }                       
        scanner.close();            
        // System.out.println(sb.toString());
    }
    
}
//  [java]
import java.util.*;

// Iroha's Strings
public class B {
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // String params = scanner.nextLine();
        int numStrings = scanner.nextInt();
        int stringLen = scanner.nextInt(); 
        scanner.nextLine();
        // scanner.next() reads up until \n it won't consume it. You need next Line to pusition the 
        // System.out.println(scanner.nextLine()); // handle of first line \n that is

        List<String> strings = new ArrayList<>();
        for (int i=0; i<numStrings; i++) {
            String curr = scanner.nextLine();
            // System.out.println("curr" + curr);
            strings.add(curr);
        }
        // I have the strings now simply sort them and concatenate
        Collections.sort(strings);
        StringBuilder sb = new StringBuilder();
        for (String s : strings) {
            // System.out.printf("String:%s, numStrings:%d, stringLen:%d %n", s, numStrings, stringLen);
            sb.append(s);
        }                       
        scanner.close();            
        // System.out.println(sb.toString());
    }