jiahuimbzuai/CoQuIR huggingface dataset:
//  [rust]
macro_rules! input {
  (source = $s:expr, $($r:tt)*) => {
      let mut iter = $s.split_whitespace();
      let mut next = || { iter.next().unwrap() };
      input_inner!{next, $($r)*}
  };
  ($($r:tt)*) => {
      let stdin = std::io::stdin();
      let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
      let mut next = move || -> String{
          bytes
              .by_ref()
              .map(|r|r.unwrap() as char)
              .skip_while(|c|c.is_whitespace())
              .take_while(|c|!c.is_whitespace())
              .collect()
      };
      input_inner!{next, $($r)*}
  };
}

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

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

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

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

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

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

  ($next:expr, $t:ty) => {
      $next().parse::<$t>().expect("Parse error")
  };
}
use std::collections::HashMap;
use std::cmp::{max,min};
fn main(){
  input!{
    n:i64,
  }
  let mut ans = n;
  for i in 1..10000001 {
    if n % i == 0 {
      let j = n / i;
      ans = min(ans,i-1 + j-1);
    }
  }
  println!("{}",ans);
}


fn is_prime(x:i64) -> bool {
  if x == 2 {return true;}
  if x < 2 || x % 2 == 0 {return false;}
  let mut j = 3;
  while j <= (x as f64).sqrt() as i64 {
      if x % j == 0 {
          return false;
      }
      j += 2;
  }
  true
}
//  [rust]
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();

    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: f64 = read();
    let mut a: f64 = 1.0;
    let mut ans: f64 = n - 1.0;

    while a <= n.sqrt(){
        let b = n / a;
        if n % a == 0.0 && a * b == n {
            if (a + b - 2.0) < ans {
                ans = a + b - 2.0;
            }
        }
        a += 1.0;
    }
    println!("{}", ans);
}
//  [swift]
import CoreFoundation
let N = Int(readLine()!)!
for i in (1...Int(sqrt(Double(N)))).reverse() {
  if N % i == 0 {
    print(i+N/i-2)
    break
  }
}
//  [typescript]
{
  const main = (input: string) => {
    const r = reader(input)
    const N = r.n()
    const { pairs } = _divisor(N)

    let res = Infinity

    pairs.forEach(([a, b]) => {
      const k = a + b - 2

      res = Math.min(res, k)
    })
    console.log(res)
  }

  const reader = (str: string) => {
    const lines = str.trim().split('\n')
    const s = () => lines.shift() || ''
    const n = () => Number(s())

    const ss = () => s().split(' ')
    const ns = () => ss().map(Number)
    const nls = () => lines.map(Number)

    return { lines, s, n, ss, ns, nls }
  }
  const _divisor = (n: number) => {
    const sq = Math.floor(Math.sqrt(n))
    const list: number[] = []
    const pairs: [number, number][] = []

    for (let i = sq; i > 0; i--) {
      if (n % i !== 0) {
        continue
      }
      list.unshift(i)
      if (sq * sq !== n) {
        list.push(n / i)
      }
      pairs.unshift([i, n / i])
    }
    return { list, pairs }
  }

  const getInput = () => require('fs').readFileSync('/dev/stdin', 'utf8')

  main(getInput())
}
//  [typescript]
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf-8');
const N: number = parseInt(input);

// k + l 回移動後  (1+k, 1+l)
const sqrtN: number = Math.floor(Math.sqrt(N));

let min: number = N;
for (let i = 1; i <= sqrtN; ++i) {
  if (N % i !== 0) {
    continue;
  }
  let count = (i - 1) + (N / i -1);
  if (min > count) min = count;
}
    
console.log(min);
//  [typescript]
import * as fs from 'fs'

const reader = (data: string) => parseInt(data, 10)

export function Main(input) {
  const N = reader(input)
  let prime = 0
  for (let i = 2; i * i <= N; i++) {
    if (N % i === 0) {
      prime = i
    }
  }

  console.log(prime ? prime - 1 + N / prime - 1 : N - 1)
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))
//  [python]
w1 = [s for s in input()]
w2 = [w1.count(a) for a in list(set(w1))]
w3 = [w for w in w2 if w % 2 == 0]
print(('Yes' if  len(w3) == len(w2) else 'No'))
//  [python]
w = list(input())
ans= "Yes"
for i in w:
    if w.count(i) % 2 != 0:
        ans = "No"
print(ans)
//  [python]
import sys
w = input()
for i in range(26):
    c = chr(ord('a') + i)
    if w.count(c) % 2 == 1:
        print("No")
        sys.exit()
print("Yes")
//  [python]
import bisect
import heapq
import itertools
import math
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18

W = sys.stdin.readline().rstrip()

if any([w % 2 for w in Counter(list(W)).values()]):
    print('No')
else:
    print('Yes')
//  [python]
import re
import doctest


class IO_for_Contest(object):
    @staticmethod
    def my_input():
        # return raw_input()
        return input()

    @staticmethod
    def read_from_input():
        # TODO: impl this for each problem
        pass

    @staticmethod
    def read_line():
        return IO_for_Contest.my_input().strip()

    @staticmethod
    def read_int():
        return int(IO_for_Contest.my_input().strip())

    @staticmethod
    def read_n_int(n):
        return list(map(
                    int,
                    re.split('\s+', IO_for_Contest.my_input().strip())))[ : n]

def solve():
    ceil = 100
    string = IO_for_Contest.read_line()[: ceil]
    s = set(string)
    for xx in string:
        s.add(xx)
    for e in s:
        if string.count(e) % 2 != 0:
            print('No')
            return
    print('Yes')


if __name__ == '__main__':
    # doctest.testmod()
    solve()
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        execute();
    }

    private static void execute() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println(checkBeautifulString(br.readLine()));
    }

    private static String checkBeautifulString(String string) {
        List<String> list = new ArrayList<>();
        for(char ch : string.toCharArray()) {
            String s = String.valueOf(ch);
            if (list.remove(s)) {
                continue;
            }
            list.add(s);
        }
        return list.isEmpty() ? "Yes" : "No";
    }
}
//  [java]
/*package whatever //do not write package name here */

import java.io.*;
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer; 
import java.util.*;


class Main {
    static class FastReader{
        BufferedReader br;
        StringTokenizer st;
        public FastReader(){
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next(){
            while(st==null || !st.hasMoreTokens()){
                try{
                    st = new StringTokenizer(br.readLine());
                }
                catch(IOException e){
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt(){
            return Integer.parseInt(next());
        }
    }
    
	public static void main (String[] args) {
		FastReader ob = new FastReader();
	    String w = ob.next();
	    int arr[] = new int[26];
	    for (int i=0;i<w.length() ; i++) {
	        int k = w.charAt(i) - 'a';
	        arr[k]=arr[k]+1;
	    }
	    for (int i=0;i<26; i++) {
	        if(arr[i]%2!=0){
	            System.out.println("No");
	            return;
	        }
	    }
	    System.out.println("Yes");
	     
	}
}
//  [java]
import java.io.*;
import java.util.*;

public class Main {

	final static long MOD = 1000000007;
	public static String[] Ws = null;
	public static int wsIndx = 0;
	public static BufferedReader in = null;
	public static void main(String[] args) throws Exception {


		String ans ="Yes";
		String w = nextString();

		int[] alp = new int['z'-'a'+1];
		Arrays.fill(alp,0);
		for(int i=0;i<w.length();i++){
			alp['z'-w.charAt(i)]++;
		}
		for(int i=0;i<alp.length;i++){
			if(alp[i]%2==1){
				ans="No";
				break;
			}
		}
		System.out.println(ans);

	}


	public static void check() throws Exception{
		if(in == null){
			in = new BufferedReader(new InputStreamReader(System.in));
		}
		if(Ws==null || Ws.length<=wsIndx){
			Ws = in.readLine().split(" ");
			wsIndx=0;
		}
	}
	public static int nextInt()throws Exception{
		check();
		return Integer.parseInt(Ws[wsIndx++]);
	}

	public static long nextLong()throws Exception{
		check();
		return Long.parseLong(Ws[wsIndx++]);
	}

	public static String nextString()throws Exception{
		check();
		return Ws[wsIndx++];
	}

	public static int[] nextInts()throws Exception{
		check();
		int[] tmp = new int[Ws.length];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=Integer.parseInt(Ws[i]);
		}
		wsIndx=Ws.length;
		return tmp;
	}

	public static long[] nextLongs()throws Exception{
		check();
		long[] tmp = new long[Ws.length];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=Long.parseLong(Ws[i]);
		}
		wsIndx=Ws.length;
		return tmp;
	}

	public static String[] nextStrings()throws Exception{
		check();
		wsIndx=Ws.length;
		return Ws;
	}


}
//  [java]
import java.io.PrintWriter;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {
	
	public static void main(String[] args) {
		// 入力
		final String w;
		try(Scanner scan = new Scanner(System.in)) {
			w = scan.next();	// 1≤|w|≤100
		}
		
		// 文字charに対応するIntegerごとに集計
		Map<Integer, List<Integer>> map = IntStream.range(0, w.length()).map(i -> w.charAt(i)).boxed()
				.collect(Collectors.groupingBy(i -> i));
			
		boolean result =map.keySet().stream().allMatch(key  -> map.get(key).size() % 2 == 0);
		
		// 出力
		try (PrintWriter out = new PrintWriter(System.out)) {
			out.println(result ? "Yes" : "No");
		}

	}

}
//  [java]
import java.util.Scanner;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {

	private static final int MOD = 1000000007;

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		String w = sc.next();

		boolean beautiful = w.chars().boxed()
				.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
				.values().stream()
				.allMatch(v -> v % 2 == 0);

		System.out.println(beautiful ? "Yes" : "No");
	}
}
//  [java]
import java.util.HashMap;
import java.util.Scanner;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by hirai on 2016/08/30.
 */
public class Main {

    /*
    public static final void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println((scanner.nextInt()
                + scanner.nextInt()
                + scanner.nextInt())
                + " "
                + scanner.next());
    }
    */
    /*
    public static final void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        final int n = scanner.nextInt();
        final int k = scanner.nextInt();
        final int x = scanner.nextInt();
        final int y = scanner.nextInt();

        int sum = 0;
        for (int i = 0; i < n; i++) {
            if (i < k) {
                sum += x;
            } else {
                sum += y;
            }
        }
        System.out.println(sum);
    }
    */
    public static final void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        final String line = scanner.next();
        HashMap<Character, AtomicInteger> map = new HashMap<>();
        for(char c : line.toCharArray()){
            if(map.containsKey(c)){
                map.get(c).incrementAndGet();
            }else{
                map.put(c, new AtomicInteger(1));
            }
        }
        if(map.entrySet()
                .stream()
                .filter(entry -> entry.getValue().get() % 2 == 0)
                .count() == map.size()){
            System.out.print("Yes");
        }else{
            System.out.print("No");
        }
    }
}
//  [cpp]
#include <cstdio>
#include <algorithm>
#include <cstring>
#define INF 0x3f3f3f3f
using namespace std;
int num[30];
char ar[105];

int main()
{
    while(~scanf(" %s",ar)){
        int len = strlen(ar);
        for(int i=0;i<len;i++){
            num[ar[i]-'a']++;
        }
        bool flag = true;
        for(int i=0;i<26;i++){
            if(num[i]%2 != 0){
                flag = false;
                break;
            }
        }
        if(flag){
            printf("Yes\n");
        }
        else
            printf("No\n");

    }
    return 0;
}
//  [cpp]
#include <cstdio>

int alp[26] = {0};

char s[101];

int main(){

  scanf("%s", s);

  int i = 0;

  while(s[i] != 0){
    int num = s[i] - 'a';
    alp[num]++;
    i++;
  }
  
  bool can = true;

  for(int i = 0; i < 26; i++){
    if(alp[i] % 2){
      can = false;
      break;
    }
  }

  printf("%s", can ? "Yes" : "No");

  return 0;

}
//  [cpp]
#include <stdio.h>

int main()
{
	char w[1000];
	scanf("%s", w);
	int alp[26];
	for(int i=0; i<26; i++){
		alp[i]=0;
	}
	for(int i=0; w[i]!='\0'; i++){
		for(int j=97; j<123; j++){
			if(w[i]==j)
				alp[j-97]++;
		}
	}
	for(int i=0; i<26; i++){
		if(alp[i]%2!=0){
			printf("No\n");	return 0;
		}
	}

	printf("Yes\n");

	return 0;
}
//  [cpp]
#include<iostream>
#include<string>

using namespace std;

int cnt[26];

int main(){
	string s;
	cin >> s;
	for(int i = 0; i < s.size(); i++){
		cnt[s[i] - 'a']++;
	}
	int a = 0;
	for(int i = 0; i < 26; i++){
		a += cnt[i] % 2;
	}
	if(a == 0){
		printf("Yes\n");
	}else{
		printf("No\n");
	}
	return 0;
}
//  [cpp]
#include <iostream>
using namespace std;

int main(){
	string w;
	cin >> w;
	int cnt[26]={};
	for(int i=0;i<w.length();i++){
		cnt[w[i]-'a']++;
	}
	for(int i=0;i<26;i++){
		// cout << (char)(i+'a') << ": " << cnt[i] << endl;
		if(cnt[i]%2 != 0){
			cout << "No" << endl;
			return 0;
		}
	}
	cout << "Yes" << endl;
}
//  [cpp]
#include <cstdio>
#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <string>
#include <cstring>
#include <sstream>
#include <algorithm>
#include <functional>
#include <queue>
#include <stack>
#include <cmath>
#include <iomanip>
#include <list>
#include <tuple>
#include <bitset>
#include <ciso646>
#include <cassert>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
typedef vector<ll> vec;

inline bool check(ll x, ll y, ll xMax, ll yMax) { return x >= 0 && y >= 0 && xMax > x && yMax > y; }
inline int toint(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class T> inline string tostring(T x) { ostringstream sout; sout << x; return sout.str(); }
template<class T> inline T sqr(T x) { return x*x; }
template<class T> inline T mypow(T x, ll n) { T res = 1; while (n > 0) { if (n & 1)res = res * x;	x = x * x;	n >>= 1; }return res; }
inline ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }

#define For(i,a,b)	for(ll (i) = (a);i < (b);(i)++)
#define rep(i,n)	For(i,0,n)
#define rFor(i,a,b)	for(ll (i) = (a-1);i >= (b);(i)--)
#define rrep(i,n)	rFor(i,n,0)
#define each(i,n)	for(auto &i : n)
#define clr(a)		memset((a), 0 ,sizeof(a))
#define mclr(a)		memset((a), -1 ,sizeof(a))
#define all(a)		(a).begin(),(a).end()
#define sz(a)		(sizeof(a))
#define tostr(a)	tostring(a)
#define dump(val) 	cerr << #val " = " << val << endl;
#define Fill(a,v)	fill((int*)a,(int*)(a+(sz(a)/sz(*(a)))),v)

const ll dx[8] = { 1, 0, -1, 0, 1, 1, -1, -1 }, dy[8] = { 0, -1, 0, 1, -1, 1, -1, 1 };

const ll mod = 1e9 + 7;
const ll INF = 1e17 + 9;

#define int ll
#define double ld

signed main() {
	cin.tie(0);
	ios_base::sync_with_stdio(false);

	string s;
	cin >> s;
	map<char, int> mp;
	each(c, s) {
		mp[c]++;
	}
	bool ok = true;
	each(i, mp) {
		if (i.second % 2) {
			ok = false;
		}
	}
	if (ok) {
		cout << "Yes" << endl;
	}
	else {
		cout << "No" << endl;
	}

	return 0;
}
//  [c]
#include <stdio.h>

int main(int argc, char *argv[])
{
    char w[128], n[26] = {0};
    int i;
    fgets(w, sizeof(w), stdin);

    for ( i = 0; w[i] != '\n'; i++ ){
        n[ w[i] - 'a' ]++;
    }
    for ( i = 0; i < 26; i++ ){
        if ( n[i]%2 != 0 ){
            printf("No\n");
            return 0;
        }
    }
    printf("Yes\n");
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    char c1,a1[101];
    int a,b,d,i,l;
    gets(a1);
    l=strlen(a1);

    for(c1='a';c1<=122;c1++)
    {
        d=0;
        for(i=0;i<l;i++)
        {
            if (c1==a1[i])
                d=d+1;
        }
        if(d%2 != 0)
        {
            printf("No");
            break;
        }
    }
    if(d%2 ==0)
        printf("Yes");
    return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>

int main(void){

  char w[101];
  char i;
  int j=0;
  int cnt[26]={0};
  int k=0;

  scanf("%s", w);

  for(i='a'; i<='z'; i++){
    for(j=0; j<strlen(w); j++){
      if(i==w[j]){
        cnt[k]++;
      }
    }
    k++;
  }

  for(i=0; i<k; i++){
    if(cnt[i]%2!=0){
      printf("No\n");
      break;
    }
  }

  if(i==k)
    printf("Yes\n");

  return 0;
}
//  [c]
main(){system("sed ':;s/\\(.\\)\\(.*\\)\\1/\\2/;t;/./cNo\ncYes'");}
//  [c]
#include <stdio.h>
#include <string.h>

int main(void){
   int n,i,alp[26];
   char str[101];

   scanf("%s",str);
   n=strlen(str);

   for(i=0;i<26;i++)
      alp[i]=0;

   for(i=0;i<n;i++)
      alp[str[i]-'a']++;

   for(i=0;i<26;i++)
      if(alp[i]%2!=0){printf("No\n");return 0;}
   printf("Yes\n");
   return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
 
 
void swap (int *x, int *y) {
  int temp;    
 
  temp = *x;
  *x = *y;
  *y = temp;
}
 
int gcd(int a,int b){
  if(a<b){
    swap(&a,&b);
  }
 
  if(b==0){
    return a;
  }
 
  int r=a%b;
  while(r!=0){
    a = b;
    b = r;
    r = (a%b);
  }
 
  return b;
}
 
/* クイックソート */
int dn(const void*a,const void*b){return*(int*)b-*(int*)a;}
 
 
int modpow(int a,int n,int mod){
  int ans=1;
  while(n>0){
    if(n & 1){
      ans=ans*a%mod;
    }
    a=a*a%mod;
    n/=2;
  }
  return ans;
}
 
int max(int a,int b){
  if(a<b){
    return b;
  }
  else{
    return a;
  }
}
 
int min(int a,int b){
  if(a<b){
    return a;
  }
  else{
    return b;
  }
}
 
void chmax(int *a,int b){
  if(*a < b){
    *a = b;
  }
 
  return;
}
 
void chmin(int *a,int b){
  if(*a > b){
    *a =b;
  }
 
  return;
}
 

int main(void){
  char w[110];
  scanf("%s",w);
  int l=strlen(w);
  int c[26];
  for(int i=0;i<26;i++){
    c[i]=0;
  }
  for(int i=0;i<l;i++){
    c[(w[i]-'a')]++;
  }
  int ans=0;
  for(int i=0;i<26;i++){
    if(c[i]%2==1){
      ans++;
    }
  }
  if(ans==0){
    printf("Yes\n");
  }else{
    printf("No\n");
  }
  return 0;
}
//  [javascript]
function myout(text){console.log(text);}//standard output
function Main(input) {
	//input = parseInt(input);
	//input = input.trim().split(" ");
	//input = input.trim().split("\n");
	//input = input.trim().split(" ").map((a)=>Number(a));
	//input = input.trim().split("\n").map((a)=>Number(a));
  var list = {};
  var list2 = [];
  for(var i = 0; i < input.length; i++){
    var tmp = input.slice(i,i+1);
    if(list[tmp] == null){
       list[tmp] = 1;
      list2.push(tmp);
    }else{
       list[tmp]++;
    }
  }
  for(var i = 0; i < list2.length; i++){
    if(list[list2[i]] % 2 == 1){
       myout("No");
      return;
       }
  }
  myout("Yes");
}

Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function Main(input) {
  const data = input.trim();
 
  var strs = data.split("");
 
  var list = [];
 
  strs.forEach((n) => {
    if (list.indexOf(n) == -1) {
      list.push(n);
    } else {
      var idx = list.indexOf(n);
      list.splice(idx, 1);
    }
  });
 
  if (list.length > 0) {
    console.log("No");
  } else {
    console.log("Yes");
  }
}
 
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const data = input.trim();

  var strs = data.split("");

  var list = [];

  strs.forEach((n) => {
    if (list.indexOf(n) == -1) {
      list.push(n);
    } else {
      var idx = list.indexOf(n);
      list.splice(idx, 1);
    }
  });

  if (list.length > 0) {
    console.log("No");
  } else {
    console.log("Yes");
  }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
	for(var i = 0;i<input.length;i++){
	    input[i] = input[i].split(" ");
	}
	
	var str = input[0][0];
	var strarr = str.split("");
	
	var count = {};
	for(var i = 0;i<strarr.length;i++){
	    if(!count[strarr[i]]){
	        count[strarr[i]] = 1;
	    }else{
	        count[strarr[i]]++;
	    }
	}
	var result = "Yes";
	for(key in count){
	    if(count[key] % 2 != 0){
	        result = "No";
	    }
	}
	//出力
    console.log(result);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
    input_stdin += data;
});
/*
process.on('SIGINT', function(){
    input_stdin_array = input_stdin.split("\n");
    main();
    process.exit();
});
*/
process.stdin.on('end', function () {
    input_stdin_array = input_stdin.split("\n");
    main();    
});

function readLine() {
    return input_stdin_array[input_currentline++];
}

/////////////// ignore above this line ////////////////////


function main() {
	var s = readLine();
	var alpha = "qwertyuiopasdfghjklzxcvbnm";
	var cont = {};
	
	/*Initialazing asociative array cont*/
	for (var i=0; i < alpha.length; i++){
		cont[alpha.charAt(i)]=0;
	}
	
	for (var i=0; i < s.length; i++){
		cont[s.charAt(i)]++;
	}
	
	for (var i=0; i < alpha.length; i++){
		if (cont[alpha.charAt(i)]%2 == 1){
			console.log("No");
			return;
		}
	}
	console.log("Yes");
}
//  [javascript]
'use strict';

const lines = require("fs").readFileSync("/dev/stdin", "utf8").trim().split("");
let answer = "Yes";

for (let i = 0; i < lines.length; i++) {
  let count = 0;
  //同じ文字を数える
  lines.forEach(letter => {
    if (lines[i] === letter)
    count++;
  });
  //数えた数が奇数ならNoを返して抜ける
  if (count % 2 === 1) {
    answer = "No";
    break;
  }
}
console.log(answer);
//  [go]
package main

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

//Util
func nextStr() string {
	sc.Scan()
	return sc.Text()
}

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

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

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

func absInt(a int) int {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func absFloat64(a float64) float64 {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func maxFloat64(a, b float64) float64 {
	if a > b {
		return a
	} else {
		return b
	}
}

func minFloat64(a, b float64) float64 {
	if a > b {
		return b
	} else {
		return a
	}
}

func str2Int(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func pow(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

func isPrime(x int) bool {
	if x == 1 {
		return false
	}
	if x == 2 {
		return true
	}
	if x%2 == 0 {
		return false
	}

	b := true
	rootx := int(math.Sqrt(float64(x)))
	i := 3
	for i <= rootx {
		if x%i == 0 {
			b = false
			break
		}
		i += 2
	}
	return b
}

func PrimeFactors(n int) (pfs []int) {
	// Get the number of 2s that divide n
	for n%2 == 0 {
		pfs = append(pfs, 2)
		n = n / 2
	}

	// n must be odd at this point. so we can skip one element
	// (note i = i + 2)
	for i := 3; i*i <= n; i = i + 2 {
		// while i divides n, append i and divide n
		for n%i == 0 {
			pfs = append(pfs, i)
			n = n / i
		}
	}

	// This condition is to handle the case when n is a prime number
	// greater than 2
	if n > 2 {
		pfs = append(pfs, n)
	}

	return
}

//Main
const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		return sc
	}()
)

var w string

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

	w = nextStr()
	N := len(w)
	m := make(map[string]int, N)

	for i := 0; i < N; i++ {
		s := string(w[i])
		//mapにkeyが存在するか判定
		if _, ok := m[s]; ok {
			m[s]++
		} else {
			m[s] = 1
		}
	}

	for _, v := range m {
		if v%2 == 1 {
			fmt.Println("No")
			return
		}
	}
	fmt.Println("Yes")
}
//  [go]
package main

import "fmt"
import "strings"

func main() {
	var w string
	fmt.Scan(&w)

	ws := strings.Split(w, "")
	cns := make(map[string]int)
	for _, ww := range ws {
		cns[ww] += 1
	}

	for _, v := range cns {
		if v%2 != 0 {
			fmt.Println("No")
			return
		}
	}

	fmt.Println("Yes")
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var w string
	fmt.Scan(&w)
	
	words := make(map[string]int)
	
	for i := 0; i < len(w); i++ {
		tmp := string(w[i])
		words[tmp]++
	}
	
	for _,v := range words {
		if v % 2 != 0 {
			fmt.Println("No")
			return
		}
	}
	fmt.Println("Yes")
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	var w string
	scanner.Scan()
	fmt.Sscan(scanner.Text(), &w)

	var b bool
	for i := 0; i < len(w); i++ {
		if strings.Count(w, string(w[i]))%2 == 1 {
			b = true
		}
	}
	if b {
		fmt.Println("No")
	} else {
		fmt.Println("Yes")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var w string
	fmt.Scan(&w)
	charCountMap := map[int32]int{}
	for _, char := range w {
		charCountMap[char]++
	}
	for _, count := range charCountMap {
		if count%2 != 0 {
			fmt.Println("No")
			return
		}
	}
	fmt.Println("Yes")
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var w string
  fmt.Scanf("%s", &w)
  
  alpha := map[rune]int{}
  for _, v := range w {
    alpha[v]++
  }
  
  ans := "Yes"
  for _, v := range alpha {
    if v % 2 != 0 {
      ans = "No"
    }
  }

  fmt.Printf("%s", ans)
}
//  [ruby]
w=gets.chomp
cnt = Array.new(26,0)
w.each_char do|c|
    cnt[c.ord - 'a'.ord] ^= 1
end

if cnt.all? {|n| n.even?}
    puts 'Yes'
else
    puts 'No'
end
//  [ruby]
s = gets.chomp.chars

hash = s.group_by { |char| char.itself }
if hash.values.all? { |array| array.size.even? }
  puts "Yes"
else
  puts "No"
end
//  [ruby]
w = gets.strip.chars

h = {}

w.each do |char|
  if h[char]
    h[char] += 1
  else
    h[char] = 1
  end
end

h.each do |k,v|
  if v.odd?
    puts 'No'
    exit 0
  end
end

puts 'Yes'
//  [ruby]
#入力を文字単位で分割し、配列へ入れる
w1 = gets.chomp.chars

w2 = w1.select { |e|
  w1.count(e).even?
}

if w1 == w2
  puts "Yes"
else
  puts "No"
end
//  [ruby]
w = gets.chomp
w_uniq = w.chars.uniq

w_uniq.each do |s|
    if w.count(s) % 2 != 0
        puts "No"
        exit
    end
end

puts "Yes"
//  [ruby]
arr = gets.chomp.split('')
i = 0
switch = true
while i < arr.size
  # p arr.count(arr[i])
  if arr.count(arr[i]).odd?
    switch = false
  end
  i += 1
end
if switch
  puts "Yes"
else
  puts "No"
end
//  [rust]
#[allow(dead_code)]
fn main() {
    let w = i::s();
    let mut ss = HashMap::new();
    for c in w {
        *ss.entry(c).or_insert(0) += 1;
    }
    for (_, i) in ss {
        if i % 2 != 0 {
            println!("{}", "No");
            return;
        }
    }
    println!("{}", "Yes");
}

#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::io::*;
#[allow(unused_imports)]
use std::num::*;
#[allow(unused_imports)]
use std::str::*;

#[allow(dead_code)]
mod i {
    use super::*;

    pub fn read<T: FromStr>() -> T {
        stdin()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>()
            .parse::<T>()
            .ok()
            .unwrap()
    }

    pub fn str() -> String {
        read()
    }

    pub fn s() -> Vec<char> {
        str().chars().collect()
    }

    pub fn i() -> i64 {
        read()
    }

    pub fn u() -> usize {
        read()
    }

    pub fn u2() -> (usize, usize) {
        (read(), read())
    }

    pub fn u3() -> (usize, usize, usize) {
        (read(), read(), read())
    }

    pub fn f() -> f64 {
        read()
    }

    pub fn c() -> char {
        read::<String>().pop().unwrap()
    }

    pub fn iv(n: usize) -> Vec<i64> {
        (0..n).map(|_| i()).collect()
    }

    pub fn iv2(n: usize) -> Vec<(i64, i64)> {
        (0..n).map(|_| iv(2)).map(|a| (a[0], a[1])).collect()
    }

    pub fn uv(n: usize) -> Vec<usize> {
        (0..n).map(|_| u()).collect()
    }

    pub fn uv2(n: usize) -> Vec<(usize, usize)> {
        (0..n).map(|_| uv(2)).map(|a| (a[0], a[1])).collect()
    }

    pub fn uv3(n: usize) -> Vec<(usize, usize, usize)> {
        (0..n).map(|_| uv(3)).map(|a| (a[0], a[1], a[2])).collect()
    }

    pub fn fv(n: usize) -> Vec<f64> {
        (0..n).map(|_| f()).collect()
    }

    pub fn cmap(h: usize) -> Vec<Vec<char>> {
        (0..h).map(|_| s()).collect()
    }
}
//  [rust]
use std::io;
use std::collections::HashMap;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let mut w:Vec<char> = buf.trim().chars().collect::<Vec<char>>();
	let mut m = HashMap::new();
	for c in w {
		match m.insert(c, 1) {
			Some(n) => {
				m.insert(c, n+1);
			},
			None => (),
		}
	}
	let mut flag = true;
	for val in m.values() {
		if *val%2 == 1 {
			flag = false;
			break;
		}
	}
	if flag {
		println!("Yes");
	}else{
		println!("No");
	}
}
//  [rust]
use std::collections::HashMap;
use std::io::stdin;

fn main() {
    let mut s = String::new();
    stdin().read_line(&mut s).ok();
    let w = s.trim();
    let mut d = HashMap::new();

    for e in w.chars() {
        *d.entry(e).or_insert(0) += 1;
    }

    println!(
        "{}",
        if d.iter().all(|e| *e.1 % 2 == 0) {
            "Yes"
        } else {
            "No"
        }
    );
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        w: String
    };

    let mut chars: Vec<char> = w.chars().collect();
    let mut is_btfl = true;
    chars.sort();

    for pair in chars.chunks(2) {
        if chars.len() % 2 != 0 {
            is_btfl = false;
            break
        }
        if pair[0] != pair[1] {
            is_btfl = false;
            break
        }
    }
    println!("{}", if is_btfl {"Yes"} else {"No"})
}
//  [rust]
#[allow(unused_imports)]
use std::{cmp::Reverse, collections::*};

#[allow(unused_imports)]
use proconio::{
    fastout, input,
    marker::{Chars, Usize1},
};

#[allow(unused_imports)]
use itertools::Itertools;

#[allow(unused_imports)]
use num::Integer;

#[fastout]
pub fn main() {
    input! {
        w: Chars,
    }
    let mut map = HashMap::new();
    for c in w {
        *map.entry(c).or_insert(0) += 1;
    }
    println!(
        "{}",
        if map.iter().all(|(_, &v)| v % 2 == 0) {
            "Yes"
        } else {
            "No"
        }
    );
}
//  [swift]
//let a: [Int] = readLine()!.split(" ").map { Int($0)! }
//print(a)

extension String: CollectionType {} // splitを使うためのおまじない

func strToInt(c:String) -> Int {
    return Int((c.unicodeScalars).first!.value)
}

let S: String = readLine()!
let a = strToInt("a")
let z = strToInt("z")
var v: [Int] = (a...z).map { _ in 0 }

for char in S {
    v[strToInt(String(char))-a]++
}
var f: Bool = true
for x in v {
    if x%2 != 0 {
        f=false
    }
}
if f {
    print("Yes")
} else {
    print("No")
}

/*
for code in "abcd".unicodeScalars {
    print(code.value)
}*/
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

var arr = [Int](repeating: 0, count: 26)
let w = readLine()!.toArray()
for c in w {
    arr[Int(c.utf8.first! - "a".utf8.first!)] += 1
}
if [Int](repeating: 0, count: 26) == (arr.map{$0 % 2}) {
    print("Yes")
} else {
    print("No")
}
//  [typescript]
function Main(input) {
    const map = {};
    for (const char of input.trim()) {
        if (map[char] === undefined) {
            map[char] = false;
        } else if (map[char] === false) {
            map[char] = true;
        } else {
            map[char] = false;
        }
    }
    let result = "Yes";
    for (const key of Object.keys(map)) {
        if (!map[key]) {
            result = "No";
            break;
        }
    }
    console.log(result);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
function main(input: string) {
  const w: string = input.split("\n")[0];
  const count = w.split("").reduce((count, char) => {
    if (count[char] == null) {
      count[char] = 1;
    } else {
      count[char] += 1;
    }
    return count;
  }, {});
  if (Object.keys(count).some((char: string) => count[char] % 2 === 1)) {
    console.log("No");
  } else {
    console.log("Yes");
  }
}

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

const Main = args => {
  const input = args.trim().split("");
  let counter = {};
  input.forEach(e => {
    if (!counter.hasOwnProperty(e)) {
      counter[e] = 1;
    } else {
      counter[e] += 1;
    }
  });

  let result = true;
  Object.keys(counter).forEach(key => {
    if ((counter[key] % 2) !== 0) result = false
  });

  if (result) {
    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 w = input[0][0];

  const chars = new Set<string>();

  w.split("").forEach((char) => {
    if (chars.has(char)) {
      chars.delete(char);
    } else {
      chars.add(char);
    }
  });

  return chars.size === 0 ? "Yes" : "No";
};

console.log(main(read()));
//  [typescript]
import * as fs from 'fs';

const inputs = fs.readFileSync('/dev/stdin', 'utf8').split(/\n/);

const isBeautifulString = (str: string): boolean => {
  const counts = {};
  Array.from(str).forEach((c) => {
    counts[c] = counts[c] === undefined ? 1 : counts[c] + 1;
  });
  return Object.values(counts).filter((v: number) => v % 2 === 1).length === 0;
};

if (isBeautifulString(inputs[0])) {
  console.log('Yes');
} else {
  console.log('No');
}
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))};
const main=()=>{
  let s=ts(),o={}
  for(let i=0;i<s.length;i++){
    if(!o[s[i]])o[s[i]]=1
    else o[s[i]]++
  }
  for(const k in o){
    if(o[k]%2==1){
      to('No')
      return
    }
  }
  to('Yes')
}
main()
//  [python]
import numpy as np
N=int(input())
def gcd(a,b):
    c=int(np.floor(a/b))
    return a-b*c
if gcd(N,2)==0:
    print(N)
else:
    print(2*N)
//  [python]
import math
import numpy as np

#line = input().split()
#N = int(line[0])
N = int(input())
#C = int(line[1])

if N % 2 == 0:
    print(N)
else:
    print(2*N)
//  [python]
n = int(raw_input())
print n << (1 if n & 1 else 0)
//  [java]
import java.util.*;

public class Main{
	public static void main(String args[]){
		int N,result;
		Scanner sc=new Scanner(System.in);
		N=Integer.parseInt(sc.next());
		result=N;
		if(N%2==1)result+=1;
		while(result%N!=0){
			result+=2;
		}
		System.out.println(result);
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.stream.IntStream;

public final class Main {

  public static void main(String[] args) throws Exception {
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
      final String source = reader.readLine();
      try {
        int input = Integer.parseInt(source);

        int result = IntStream.iterate(1, i -> i + 1)
            .parallel()
            .map(i -> i * input)
            .filter(i -> (i & 1) == 0)
            .findFirst()
            .orElseThrow(RuntimeException::new);

        System.out.println(result);
      } catch (NumberFormatException exception) {
        throw new InternalError("\"" + source + "\" is not a valid number.");
      }
    }
  }

}
//  [java]
import java.util.*;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    
    int ans = N % 2 == 0 ? N : 2*N;
    System.out.println(ans);
  }
}
//  [cpp]
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
#include <unistd.h>
#include <stdio.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll INF = 1LL << 60;
const ll mod = 1000000007;
typedef pair<ll,ll> P;
using graph = vector<vector<ll>>;
template<class T> inline bool chmax(T& a, T b){if(a < b){a = b; return true;}return false;}
template<class T> inline bool chmin(T& a, T b){if(a > b){a = b; return true;}return false;}
ll gcd(ll a,ll b){
    if(a < b)swap(a,b);
    if(a % b == 0)return b;
    else return gcd(b,a%b);
}
bool isp(ll n){
    bool res = true;
    if(n == 1)return false;
    else{
        for(ll i = 2;i * i <= n;i++){
            if(n % i == 0){
                res = false;
                break;
            }
        }
        return res;
    }
}
//printf("%.10f\n", N);
/*
ll fibo(ll n){
    if(memo[n] != 0)return memo[n];
    if(n <= 1)return n;
    else return memo[n] = fibo(n - 1)+ fibo(n - 2);
}*/
/*  vector<ll> vec = {1,2,5,6,8,9,10};
    cout << binary_search(all(vec),5) << endl; -> true*/
/*
    vector<ll> vec = {1,2,5,6,8,9,10};
    auto n = upper_bound(all(vec),4);
    cout << *n << endl; -> 5*/
/*
    cout << fixed << setprecision(15);
    */
int main(){
    ll N;
    cin >> N;
    usleep(1998999);
    if(N % 2 == 0)cout << N << endl;
    else cout << 2 * N << endl;
}
//  [cpp]
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
#include <unistd.h>
#include <stdio.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll INF = 1LL << 60;
const ll mod = 1000000007;
typedef pair<ll,ll> P;
using graph = vector<vector<ll>>;
template<class T> inline bool chmax(T& a, T b){if(a < b){a = b; return true;}return false;}
template<class T> inline bool chmin(T& a, T b){if(a > b){a = b; return true;}return false;}
ll gcd(ll a,ll b){
    if(a < b)swap(a,b);
    if(a % b == 0)return b;
    else return gcd(b,a%b);
}
bool isp(ll n){
    bool res = true;
    if(n == 1)return false;
    else{
        for(ll i = 2;i * i <= n;i++){
            if(n % i == 0){
                res = false;
                break;
            }
        }
        return res;
    }
}
//printf("%.10f\n", N);
/*
ll fibo(ll n){
    if(memo[n] != 0)return memo[n];
    if(n <= 1)return n;
    else return memo[n] = fibo(n - 1)+ fibo(n - 2);
}*/
/*  vector<ll> vec = {1,2,5,6,8,9,10};
    cout << binary_search(all(vec),5) << endl; -> true*/
/*
    vector<ll> vec = {1,2,5,6,8,9,10};
    auto n = upper_bound(all(vec),4);
    cout << *n << endl; -> 5*/
/*
    cout << fixed << setprecision(15);
    */
int main(){
    ll N;
    cin >> N;
    usleep(1998000);
    if(N % 2 == 0)cout << N << endl;
    else cout << 2 * N << endl;
}
//  [cpp]
#include <iostream>
using namespace std;

int main() {
    int N;
    int i;
    cin >> N;
    for (i = N ; i < 2147483647; i++){
        if( i % 2 == 0 && i % N == 0)
        break;
    }
    cout << i << "\n";
}
//  [c]
#include <stdio.h>

int main()
{
    int n,i;

    scanf("%d", &n);

    for(i=n;;i++){
        if(i%2==0 && i%n ==0){
            printf("%d\n" , i);
            break;
        }   
    }
}
//  [c]
#include <stdio.h>
#define MAX 9999999999

int main(void)
{
    int mod;
    int N;
     
     scanf("%d", &N);
     mod = N; //初期値
     while(mod <= MAX)
     {
         if ((mod%2 == 0) && (mod%N == 0)){
               printf("%d", mod);
               return 0;
         }
         mod++;
     }
     return 0;
}
//  [c]
#include <stdio.h>


int main(){
	int n, aux;
	scanf("%i", &n);
	aux=n;
	while(n>0){
		if(n%2==0){
			if(n%aux==0){
				printf("%i\n", n);
				return 0;
			}
			else
				n=n+2;

		}
		else
			n++;
	}
	
}
//  [javascript]
'use strict'

function Main(input) {
  const N = Number(input);
  
  if(N % 2 === 0) {
    console.log(N);
  } else {
    console.log(N * 2);
  }

}

Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function main(input) {
  var input = parseInt(input);
  var answer = input;
  if (input % 2 != 0) {
  	answer = input * 2;
  }
  console.log(answer);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  var input = parseInt(input);

  if (input % 2 == 0) {
  	answer = input;
  } else {
  	answer = input * 2;
  }
  console.log(answer);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

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

func main() {
	r := bufio.NewReader(os.Stdin)
	s, _ := r.ReadString('\n')
	s = strings.TrimRight(s, " \t\n")
	N, _ := strconv.Atoi(s)

	if N%2 == 0 {
		fmt.Println(N)
	} else {
		fmt.Println(N * 2)
	}
}
//  [go]
package main
 
import (
  "fmt"
)
 
func main() {
  var n int
  fmt.Scanf("%d", &n)

  ans := n
  if n % 2 != 0 {
    ans = 2 * n
  }
  fmt.Printf("%d\n", ans)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func intScanner() int {
	n, _ := strconv.Atoi(Scanner())
	return n
}

func floatScanner() float64 {
	n, _ := strconv.ParseFloat(Scanner(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func stringSliceScanner(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scanner()
	}
	return a
}
func intSliceScanner(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = intScanner()
	}
	return a
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	n := intScanner()
	if n%2 == 0 {
		fmt.Println(n)
	} else {
		fmt.Println(n * 2)
	}
}
//  [ruby]
require 'prime'
require 'set'
require 'tsort'
include Math
ALP = ('a'..'z').to_a
INF = 0xffffffffffffffff
def max(a,b);              a > b ? a : b                              end
def min(a,b);              a < b ?  a : b                             end
def swap(a,b);             a, b = b, a                                end
def gif;                   gets.to_i                                  end
def gff;                   gets.to_f                                  end
def gsf;                   gets.chomp                                 end
def gi;                    gets.split.map(&:to_i)                     end
def gf;                    gets.split.map(&:to_f)                     end
def gs;                    gets.chomp.split.map(&:to_s)               end
def gc;                    gets.chomp.split('')                       end
def pr(num);               num.prime_division                         end
def pr?(num);              Prime.prime?(num)                          end
def digit(num);            num.to_s.length                            end
def array(s,ini=nil);      Array.new(s){ini}                          end
def darray(s1,s2,ini=nil); Array.new(s1){Array.new(s2){ini}}          end
def rep(num);              num.times{|i|yield(i)}                     end
def repl(st,en,n=1);       st.step(en,n){|i|yield(i)}                 end

n=gif
if n % 2 == 0
puts n
else
  puts n*2
end
//  [ruby]
n = gets().to_i

(1..100000000).each do |m|
  if (n * m).even?
    puts n * m
    break
  end
end