jiahuimbzuai/CoQuIR huggingface dataset:
//  [rust]
#![allow(unused_imports)]
use itertools::Itertools;
use proconio::{input, marker::*};
use std::cmp::*;
use std::collections::*;
use superslice::*;
use text_io::read;

fn main() {
    input! {
        s: Chars,
    }

    let n = s.len();
    let bef = Vec::from(&s[0..n / 2]);
    let mut aft = Vec::from(&s[(n + 1) / 2..n]);
    aft.reverse();

    let mut ans = 0;

    for i in 0..n / 2 {
        if bef[i] != aft[i] {
            ans += 1;
        }
    }

    println!("{}", ans);
}
//  [rust]
fn main() {
    let s = read::<String>();
    let v: Vec<char> = s.chars().into_iter().collect();
    let n = v.len();

    let mut ret = 0;
    for i in 0..n/2 {
        if v[i] != v[n-1-i] {
            ret += 1;
        }
    }

    println!("{}", ret);
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().parse().ok().unwrap()
}
//  [rust]
// Vicfred
// https://atcoder.jp/contests/abc147/tasks/abc147_b
// string manipulation
use std::io;

fn main() {
    let mut s = String::new();

    io::stdin()
        .read_line(&mut s)
        .unwrap();

    let s = s.trim();

    let n = s.len();
    let s: Vec<char> = s.chars().collect();

    let mut answer = 0;

    for i in 0..n-1 as usize {
        if s[i] != s[n-i-1] {
            answer += 1;
        }
    }

    println!("{}", answer/2);

}
//  [rust]
// Vicfred
// https://atcoder.jp/contests/abc147/tasks/abc147_b
// string manipulation
use std::io;

fn main() {
    let mut s = String::new();

    io::stdin()
        .read_line(&mut s)
        .unwrap();

    let s = s.trim();

    let n = s.len();
    let s: Vec<char> = s.chars().collect();

    let mut answer = 0;

    for i in 0..n-1 as usize {
        if s[i] != s[n-i-1] {
            answer += 1;
        }
    }

    println!("{}", answer);

}
//  [rust]
// Vicfred
// https://atcoder.jp/contests/abc147/tasks/abc147_b
// string manipulation
use std::io;

fn main() {
    let mut s = String::new();

    io::stdin()
        .read_line(&mut s)
        .unwrap();

    let s = s.trim();

    let n = s.len();
    let s: Vec<char> = s.chars().collect();

    let mut answer = 0;

    for i in 0..n-1 as usize {
        println!("{}", i);
        if s[i] != s[n-i-1] {
            answer += 1;
        }
    }

    println!("{}", answer);

}
//  [swift]
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

let S=readLine()!

var diff=0

var i=0

for _ in S{
  let c1=S[S.index(S.startIndex,offsetBy:i)]
  let c2=S[S.index(S.endIndex,offsetBy:-i-1)]
  if c1 != c2{diff+=1}
  i+=1
}

print(diff/2)
//  [swift]
let arr=Array(readLine()!.characters)

var i = 0
var ans = 0
while ( i < arr.count / 2 ) {
  if(arr[i] != arr[arr.count-i-1]) {
    ans += 1
  }
  i+=1
}

print(ans)
//  [swift]
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
func main() {
    let S = Array(readLine()!)
    var ans = 0
    for i in stride(from: 0, to: S.count/2, by: 1){
        if S[i] != S[S.count-i-1]{
            ans += 1
        }
    }
    print(ans)
}
main()
//  [swift]
let s=readLine()!
let n=s.count
var S=Array(s)
var count=0
if n%2==0{
  for i in 0...n/2-1{
    if S[i] != S[-1-i]{
      count+=1
    }
  }
}else{
   for i in 0...(n-1)/2-1{
    if S[i] != S[-1-i]{
      count+=1
    }
  }
}
print(count)
//  [typescript]
import * as fs from 'fs';

//in
// abcdabc
//out
// 2
const main = (inp: string) => {
    let ans: number = 0;

    for (let i = 0; i < Math.floor(inp.length / 2); i++) {
        if (inp[i] !== inp[inp.length - i - 1]) {
            ans++;
        }
    }
    console.log(ans);
};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]

function Main(input: string) {

    let target = input.split('\n')[0].split('');
    let center = Math.floor(target.length / 2);
    let count = 0;

    target.some((v, i, arr) => {
        if (i >= center) {
            return true;
        }
        if (v !== arr[(target.length - 1) - i]) {
            count++;
        }
    })

    console.log(count)

}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
function main(input: string) {
  const S = input.split("");
  let c = 0;
  for(let i = 0, bi = S.length - 1, l = Math.ceil(S.length / 2); i < l; i++, bi--) {
    if (S[i] !== S[bi]) c++
  }
  console.log(c);
}

main(
  require("fs")
    .readFileSync("/dev/stdin", "utf8")
    .trim()
);
//  [typescript]
import * as fs from 'fs';

//in
// abcdabc
//out
// 2
const main = (inp: string) => {
    let ans: number = 0;

    for (let i = 0; i < Math.floor(inp.length / 2); i++) {
        console.log(`${inp[i]}  ${inp[inp.length - i - 1]}`);
        if (inp[i] !== inp[inp.length - i - 1]) {
            ans++;
        }
    }
    console.log(ans);
};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
//const n = +input[0];
//const a = [];
//for(let i=0;i<n;i++){
//	a.push(input[i+1].split(" ").map((x:string):number=>+x));
//}

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);

function compareFunc(a, b){
    return a-b;
}

const s: string[] = input[0].split('');
const ss: string[] = s.slice().reverse();

let ans: number = 0;
const len: number = Math.floor(s.length/2)
for(let i = 0; i < len; i++){
    if(s[i] !== ss[i]){
        ans++
    }
    console.log(s[i],ss[i]);
}
console.log(ans);
//  [typescript]
const fs = require('fs');

const main = () => {

    const input: string = fs.readFileSync('/dev/stdin', 'utf8');
  	const inputArr = input.split("");
    let hugs = 0;
    for (let i = 0; i < Math.ceil(inputArr.length/2); i++) {
        if (inputArr[i] != inputArr[inputArr.length-1-i]) {
            hugs++;
        }
    }
    console.log(hugs);
};

main();
//  [python]
N = int(input())
Slist = input().split()
A = Slist[0]
B = Slist[1]

for i in range (N):
	print(A[i],B[i], end='',sep='')
//  [python]
N = int(input())
S, T = input().split()
ans = ''
for s, t in zip(S, T):
    ans += s + t
print(ans)
//  [python]
n = int(input())
s,t = input().split()
new = ''
for i in range(n):
    new += s[i]
    new += t[i]
print(new)
//  [python]
n=int(input())
s,t=input().split()
ans=0
for i in range(n):
    ans=ans+s[i]+t[i]
print(ans)
//  [python]
n=int(input())
ans=s[0]+t[0]
s,t=input().split()
for i in range(1,n):
    ans=ans+s[i]+t[i]
print(ans)
//  [python]
n=int(input().split())
ans=s[0]+t[0]
s,t=input().split()
for i in range(1,n):
    ans=ans+s[i]+t[i]
print(ans)
//  [java]


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String [] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
		 int n =Integer.valueOf(br.readLine());
		 String [] z =br.readLine().split(" ");
		 String nums1 =z[0];
		 String nums2 =z[1];
		
         for(int i=0;i<n;i++) {
        	 System.out.print(nums1.charAt(i)+nums2.charAt(i));
		 }
    

}
}
//  [java]


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String [] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
		 int n =Integer.valueOf(br.readLine());
		 String [] z =br.readLine().split(" ");
		 String nums1 =z[0];
		 String nums2 =z[1];
		
         for(int i=0;i<nums1.length();i++) {
        	 System.out.print(nums1.charAt(i)+nums2.charAt(i));
		 }
    

}
}
//  [java]


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String [] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
		 int n =Integer.valueOf(br.readLine());
		 String [] z =br.readLine().split(" ");
		 System.out.print(z);
		 String nums1 =z[0];
		 String nums2 =z[1];
		
         for(int i=0;i<n;i++) {
        	 System.out.print(nums1.charAt(i)+nums2.charAt(i));
		 }
    

}
}
//  [cpp]
#include<stdio.h>
int main()
{
	int i,n;
	char a[105],b[105],c[205];
	scanf("%d%s%s",&n,a,b);
	for(i=0;i<n;i++)
	  c[i*2]=a[i],c[i*2+1]=b[i];
	c[n*2]='\0';
	printf("%s",c);
	return 0;
}
//  [cpp]
#include<stdio.h>
int main(){
  int n;
  scanf("%d",&n);
  char str1[n];
  char str2[n];
  scanf("%s %s",str1,str2);
  for(int i=0;i<n;i++){
    printf("%c%c",str1[i],str2[i]);
  }
  return 0;
}
//  [cpp]
#include<cstdio>
const int N=100+10;
int n;
char a[N],b[N];
int main()
{
	scanf("%d%s%s",&n,a+1,b+1);
	for(int i=1;i<=n;i++)
		printf("%c%c",a[i],b[i]);
	return 0;
}
//  [cpp]
#if __has_include("debug.h")
    #include "debug.h"
#else  
#include <bits/stdc++.h>
using namespace std;
#define d(...) 2;
#endif

#define int long long int
#define ld long double

#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl "\n"      

#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
#define ff first
#define ss second
#define eps 1e-10
#define PI acos(-1LL)

#define gcd(a,b)            __gcd((a),(b))
#define lcm(a,b)            ((a*b)/gcd(a,b))

void solve();

int32_t main()
{
    #ifdef DEBUG
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
    #endif 

    fast
    
    int t = 1;
	// cin>>t;
	
	while(t--)
	    solve();
	return 0;  
}

void solve()
{
	int i,j;
	int n;
	string t,s,f="";
	cin>>n>>s>>t;

	for(i=0;i<s.length();i++)
	{
		if(i&1)
		{
			f+=t[i];
		}
		else
		{
			f+=s[i];
		}
	}
	cout<<f<<endl;

}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main(void){
  int n; cin>>n;
  string s,t; cin>>s>>t;
  string res;
  for(int i=0; i<n; ++i) res+=s[i]+t[i];
  cout<<res;
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define repr(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define reprrev(i,a,b) for(int i=b-1;i>=a;i--) // [a, b)
#define reprev(i,n) reprrev(i,0,n)
#define _GLIBCXX_DEBUG
                    
using ll = long long;
using ull = unsigned long long;
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; }
const ll mod = 1e9+7;
void chmod(ll &M){
  if(M >= mod) M %= mod;
  else if(M < 0){
     M += (abs(M)/mod + 1)*mod;
    M %= mod;
}
}
ll modpow(ll x, ll n){
   if(n==0) return 1;
  ll res=modpow(x, n/2);
 if(n%2==0) return res*res%mod;
else return res*res%mod*x%mod;
}


int getl(int i, int N) { return i==0? N-1:i-1; };
int getr(int i, int N) { return i==N-1? 0:i+1; };
long long GCD(long long a, long long b) {
  if (b == 0) return a;
  else return GCD(b, a % b);
}

using namespace std;

int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  int N; cin >> N;
  string S, T;
  cin >> S >> T;
  string R;
  rep(i, 2*N) {
    R += S.at(i);
    R += T.at(i);
  }

  cout << R << endl;
}
//  [c]
#include <stdio.h>

int main() {
	int n, i;
	char s[101], t[101];
	scanf("%d %s %s", &n, s, t);
	for(i = 0; i < n; i++)
		printf("%c%c", s[i], t[i]);
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#define Fori(g) for(int i=0;i<g;i++)
#define	Forj(g) for(int j=0;j<g;j++)
#define min(aa,bb) (aa<bb)?aa:bb
#define max(aa,bb) (aa<bb)?bb:aa

int main(){
	char s[100],t[100],sum[300];
	int c=0;
	int n;
	scanf("%d",&n);
	scanf("%s%s",s,t);
	for(int i=0;i<strlen(s);i++){
		printf("%c",s[i]);
		printf("%c",t[i]);
	}

	return 0;
}
//  [c]
#include"stdio.h"
#include"math.h"



int main() {
	char a[101], b[101],ans[201];
	int n;
	scanf("%d", &n);
	scanf("%s %s", &a, &b);
	for(int i=0;i<201;i++)	ans[i] = 0;

	for (int i = 0;i < n;i++) {
		ans[2*i] = a[i];
		ans[2*i+1] = b[i];
	}
	printf("%s", ans);
	return 0;
}
//  [c]
#include<stdio.h>
int main(void){
    int n;
    int i = 0;
    char s[105];
    char t[105];
    scanf("%d",&n);
    scanf("%s%s",s,t);
    while (i < n)
    {
        printf("%c%c\n",s[i],t[i]);  
        i++;
    }
    
    return 0;
}
//  [c]
#include<stdio.h>
int main(void){
    int n;
    char s[100];
    char t[100];
    scanf("%d",&n);
    scanf("%s%s",s,t);
    char a[210];
    for (int i = 0; i < n; i++)
    {
        a[2 * i] = s[i];
    }
    for (int i = 0; i < n; i++)
    {
        a[2 * i + 1] = t[i];
    }
    printf("%s\n",a);  
    return 0;
}
//  [c]
#include<stdio.h>
int main(void){
    int n;
    char s[100];
    char t[100];
    scanf("%d",&n);
    scanf("%s%s",s,t);
    char a[100];
    for (int i = 0; i < n; i++)
    {
        a[2 * i] = s[i];
    }
    for (int i = 0; i < n; i++)
    {
        a[2 * i + 1] = t[i];
    }
    printf("%s\n",a);  
    return 0;
}
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim().split('\n');
  const a = Number(arr[0]);
  const b = arr[1].split(' ')[0];
  const c = arr[1].split(' ')[1];
  let str = '';
  
  for (let i = 0; i < a; i ++) {
    str += (b[i] + c[i]);
  }

  console.log(str);
}

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



function Main(input) {
  input = input.trim().split('\n')
  const N = parseInt(input[0])
  const array = input[1].split(' ')
  const S = array[0]
  const T = array[1]
  let ans = ''
  for(let i = 0; i < N; ++i) {
    ans += S[i]
    ans += T[i]
  }

  console.log(ans)
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
    var args = input.trim().split('\n');
    var text = args[1].split(' ');
    var ans = "";
    for(var i = 0;i <= Number(args[0]);i++) {
        ans += text[0].charAt(i);
        ans += text[1].charAt(i);
    }
    console.log(ans);
}
/* 
 var input = `2
aa aa`;
Main(input);
 */  
  Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim().split('\n');
  const a = NUmber(arr[0]);
  const b = arr[1].split(' ')[0];
  const c = arr[1].split(' ')[1];
  let str = '';
  
  for (let i = 0; i < a; i ++) {
    str += (b[i] + c[i]);
  }
  
  console.log(str);
}

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

function Main(input) {
    const lines = input.trim().split("\n");
    const N = parseInt(lines[0]);
    const [S, T] = lines[1].split(" ");

    let answer = "";
    for (var i = 0; i < N; i++) {
        answer += S[i] + T[i]
    }
    console.log(answer)
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
  input = input.trim().split('\n')
  const N = parseInt(input[0])
  const array = input[1].split(' ')
  const S = array[0]
  const T = array[1]
  let ans = ''
  for(let i = 0; i < N; ++i) {
    ans += S[i]
    ans += T[i]
  }
 
  console.log(ans)
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

const (
	initialBufSize = 1e4
	maxBufSize     = 1e6 + 7
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	N := nextInt()
	S, T := nextLine(), nextLine()
	ans := make([]byte, 0)
	for i := 0; i < N; i++ {
		ans = append(ans, S[i], T[i])
	}
	fmt.Println(string(ans))
}

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

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

	n := nextInt()
	s := nextStr()
	t := nextStr()
	for i := 0; i < n; i++ {
		fmt.Printf("%c%c", s[i], t[i])
	}

	fmt.Println("")
}

// ---- readfunc
func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}
func nextStr() string {
	sc.Scan()
	return sc.Text()
}
//  [go]
package main

import "fmt"

func main() {
	var N int
	fmt.Scanf("%d", &N)
	S := ""
	var s, t string
	fmt.Scanf("%s %s", &s, &t)
	for i := 0; i < N; i++ {
		S += string(s[i]) + string(t[i])
	}
	fmt.Println(S)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var N int
	var S, T string
	fmt.Scanf("%d\n%s %s\n", &N, &S, &T)
	s := make([]rune, 2*N)
	for i := 0; i < N; i++ {
		s = append(s, []rune(S)[i], []rune(T)[i])
	}
	fmt.Println(string(s))
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func nextString() string {
	sc.Scan()
	return sc.Text()
}
func main() {
	sc.Split(bufio.ScanWords)
	N := nextInt()
	S, T := nextString(), nextString()
	fmt.Println(S, T)

	var ans string
	for i := 0; i < N; i++ {
		ans += string(S[i]) + string(T[i])
	}
	fmt.Println(ans)
}
//  [go]
package main

import (
	"fmt"
	_ "strings"
)

func main() {
	var n, str string
	fmt.Scanln(&n)
	fmt.Scanln(&str)

	//parts := strings.Split(str, " ")
	//fmt.Print(run(parts[0], parts[1]))

	fmt.Print(run2(str))
}

func run(a, b string) string {
	buf := make([]byte, len(a)+len(b))
	for i := 0; i < len(a); i++ {
		n := i * 2
		buf[n] = a[i]
		buf[n+1] = b[i]
	}
	return string(buf)
}

func run2(str string) string {
	secondStart := (len(str) + 1) / 2
	firstEnd := secondStart - 2
	buf := make([]byte, len(str)-1)
	for i := 0; i <= firstEnd; i++ {
		n := i * 2
		buf[n] = str[i]
		buf[n+1] = str[i+secondStart]
	}
	return string(buf)
}
//  [ruby]
a = gets.to_i

b, c = gets.split

d = []

a.times do |i|
  d << b[i]
  d << c[i]
end

puts d.join
//  [ruby]
lines = []
while line = gets
    lines << line.chomp.split(' ')
end

N = lines[0][0].to_i
S = lines[1][0]
T = lines[1][1]

answer = ""
for i in 1..N do
  answer += S[i-1]
  answer += T[i-1]
end

print answer
//  [ruby]
N = gets.to_i
S,T = gets.chomp.split
str = ''
N.times{|i| str += S[i] + T[i]}
puts str
//  [ruby]
_,s,t=`dd`.split.map{|s|s.split ' '}
puts s.zip(t).flatten.join
//  [ruby]
_,s,t=`dd`.split
puts s.zip(t).flatten.join
//  [ruby]
input = readlines()

n = input.shift.chomp.to_i
s, t = input.shift.chomp.split("\s").map{|x| x.to_i}

r = ''
(1..n).each do |i|
  r += s[i - 1]
  r += t[i - 1]
end

puts r
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();

    let answer = solve(&buf);

    println!("{}", answer);
}

fn solve(input: &str) -> String {
    let mut iterator = input.split_whitespace();

    let n: usize = iterator.next().unwrap().parse().unwrap();
    let s: Vec<char> = iterator.next().unwrap().chars().collect();
    let t: Vec<char> = iterator.next().unwrap().chars().collect();

    let mut ans = String::new();
    for i in 0..n {
        ans.push(s[i]);
        ans.push(t[i]);
    }

    return ans;
}
//  [rust]
fn main() {
    let n = read::<usize>();
    let st = read_vec::<String>();
    let s: Vec<char> = st[0].chars().into_iter().collect();
    let t: Vec<char> = st[1].chars().into_iter().collect();
    let mut ret: Vec<char> = Vec::new();

    for i in 0..n {
        ret.push(s[i]);
        ret.push(t[i]);
    }

    println!("{}", ret.into_iter().collect::<String>());
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}
//  [rust]
#include <bits/stdc++.h>

#define ll long long
#define pi (acos(-1))
#define rep(i, n) for (unsigned long long i = 0; i < (unsigned long long)(n); ++i)
using namespace std;
std::vector<unsigned ll> genprimevec(const unsigned ll N);

int main()
{
    int n;
    cin>>n;string s,t;
    cin>>s>>t;
string ans;
    rep(i,n){
	  ans.push_back(s[i]);
	ans.push_back(t[i]);  
    }
    cout<<ans<<endl;
    return 0;
}

/*author  https://qiita.com/drken/items/0c88a37eec520f82b788*/
ll extgcd(ll a, ll b, ll &x, ll &y)
{
    if (b == 0)
    {
        x = 1, y = 0;
        return a;
    }
    ll d = extgcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}


std::vector<unsigned ll> genprimevec(const unsigned ll N)
{
    std::vector<bool> is_prime(N + 1);
    for (unsigned ll i = 0; i <= N; i++) { is_prime[i] = true; }
    std::vector<unsigned ll> P;
    for (unsigned ll i = 2; i <= N; i++)
    {
        if (is_prime[i])
        {
            for (unsigned ll j = 2 * i; j <= N; j += i) { is_prime[j] = false; }
            P.emplace_back(i);
        }
    }
    return P;
}
//  [rust]
fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());

    let n: usize = sc.read();
    let s: Vec<char> = sc.chars();
    let t: Vec<char> = sc.chars();

    let mut ret: Vec<char> = vec![];
    for i in 0..n {
        ret.push(s[i]);
        ret.push(t[i]);
    }
    let s: String = ret.iter().collect();
    println!("{}", s);

}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);
impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> IO<R, W> {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: std::ops::Deref<Target = str>>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
//  [rust]
// Original: https://github.com/tanakh/competitive-rs
#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };

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

    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };

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

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

mod util {
    #[allow(dead_code)]
    pub fn chmin<T>(x: &mut T, y: T) -> bool
    where
        T: PartialOrd + Copy,
    {
        *x > y && {
            *x = y;
            true
        }
    }

    #[allow(dead_code)]
    pub fn chmax<T>(x: &mut T, y: T) -> bool
    where
        T: PartialOrd + Copy,
    {
        *x < y && {
            *x = y;
            true
        }
    }

    /// 整数除算切り上げ
    #[allow(dead_code)]
    pub fn roundup(a: i64, b: i64) -> i64 {
        (a + b - 1) / b
    }

    #[allow(dead_code)]
    pub fn ctoi(c: char) -> i64 {
        c as i64 - 48
    }
}

#[allow(unused_imports)]
use util::*;

#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, VecDeque};

fn main() {
    input! {
        n:usize,s:chars,t:chars
    }

    let mut ans = vec![];
    for (a, b) in s.iter().zip(t.iter()) {
        ans.push(*a);
        ans.push(*b);
    }

    let ans = ans.iter().collect::<String>();
    println!("{}", ans);
}
//  [swift]
let n=Int(readLine()!)!
let arr=Array(readLine()!.characters)

var i = 0
var output = ""
for i in 0..<n {
  output += String(arr[i])
  output += String(arr[i  + 1 + n])
}

print(output)
//  [swift]
let n=Int(readLine()!)!
let st=readLine()!.split(separator:" ")
let s=st[0]
let t=st[1]
let S=Array(s)
let T=Array(t)
var ans:[Character]=[]
for i in 0...n-1{
  ans.append(S[i])
  ans.append(T[i])
}
for a in ans{
  print(a,terminator:"")
}
//  [swift]
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readStr() -> [String] {
  let str:String = readLine()!
  let arr:[String] = str.components(separatedBy: " ")
  return arr
}

let nb=readInts()
let n=nb[0]
let strs=readStr()
let S=strs[0]
let T=strs[1]

var ans:String=""

for i in 0..<n{
  let c1=S[S.index(S.startIndex,offsetBy:i)]
  let c2=T[T.index(T.startIndex,offsetBy:i)]
  ans+=String(c1)+String(c2)
}

print(ans)
//  [swift]
import Foundation

func getInt () -> Int64{ return Int64(readLine()!)!}
func getString() -> String { return String(readLine()!)}
func getInts() -> [Int64] {return readLine()!.components(separatedBy: " ").map{(Int64($0)!)}}
func getStrings() -> [String] {return readLine()!.components(separatedBy: " ").map{(String($0))}}
var N = getInt()
var strArray = getStrings()
var ans : [String] = []
strArray[0].map{String($0)}.forEach{ans.append($0)}
var idx = 0;
strArray[1].map{String($0)}.forEach{
    ans[idx] += $0;
    idx += 1
    
}
print(ans.reduce("",+))
//  [swift]
var N = (Int)(readLine()!)!
var str_ : String? = readLine()
if let str  = str_ {
for c in str.characters{
  if c != " "{
    print(c,terminator: "")
  }
}
}
//  [swift]
var n = Int(readLine()!)!
var str = readLine()!
var s = ""
var t = ""
var toggle = false

for c in str {
    if c == " " {
        toggle = true
        continue
    }
    
    if toggle {
        t.append(c)
    }
    else {
        s.append(c)
    }
}

var ans = ""
for i in 1...n {
    ans.append(s[s.index(s.startIndex, offsetBy: i - 1)])
    ans.append(t[t.index(t.startIndex, offsetBy: i - 1)])
}
//  [typescript]

function Main(input: string) {
    let splited = input.split('\n');
    let N = parseInt(splited[0]);
    let S = splited[1].split(' ')[0].split('');
    let T = splited[1].split(' ')[1].split('');

    let ans = '';

    for (let i = 0; i < N; i++) {
        ans += S[i] + T[i];
    }
    console.log(ans);
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
//const n = +input[0];
//const a = [];
//for(let i=0;i<n;i++){
//	a.push(input[i+1].split(" ").map((x:string):number=>+x));
//}

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);

const n : number = +input[0];
const [s, t] : string[] = input[1].split(' ');
const ss : string[] = s.split('');
const tt : string[] = t.split('');

let ans : string = '';

for(let i = 0; i < n; i++){
    ans+=ss[i];
    ans+=tt[i];
}
console.log(ans);
//  [typescript]
function Main(input) {
	const lines = input.split('\n');
	const [s, t] = lines[1].split(' ').map(v => v.split(''));
	const result = s.reduce((acc, v, i) => acc + v + t[i], '');

	console.log(result);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
// Template from https://techracho.bpsinc.jp/jhonda/2019_08_05/78537

// input macro for competive-programming from https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        input_inner!{$s, $($r)*}
    };
}

#[allow(unused_macros)]
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)*}
    };

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

#[allow(unused_macros)]
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, bytes) => {
        read_value!($iter, String).into_bytes()
    };

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

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();

    println!("{}", solve(&s));
}

macro_rules! test {
    ($($exp_input:expr => $output:expr),* $(,)*) => {
        #[test]
        fn solve_test() {
            $(
                let start = std::time::Instant::now();
                let input = solve($exp_input);
                let end = start.elapsed();
                assert_eq!(input, $output, "{}.{:03}", end.as_secs(), end.subsec_millis());
                assert!(end.as_secs() <= 2, "expected_sec: {}sec, actual_sec: {}sec", 2, end.as_secs());
                assert!(end.as_secs() <= 1, "expected_sec: {}sec, actual_sec: {}sec", 1, end.as_secs());
                assert!(end.subsec_millis() <= 10, "expected_ms: {}ms, actual_ms: {}ms", 10, end.subsec_millis());
                assert!(end.subsec_millis() <= 2, "expected_ms: {}ms, actual_ms: {}ms", 2, end.subsec_millis());
            )*
        }
    };
}

test! {
r#"2
ip cc"# => r#"icpc"#,
}

fn solve(src: &str) -> String {
    let mut src_iter = src.split_whitespace();
    input! {
        source = src_iter,
        n: usize,
        s: chars,
        t: chars,
    }
    let mut ans = "".to_string();

    for i in 0..n {
        ans.push_str(&s[i].to_string());
        ans.push_str(&t[i].to_string());
    }

    ans.to_string()
}
//  [python]
H,W = map(int,input().split())

if H == 1 or W == 1:
    print(1)
else:
    if (H % 2) * (W % 2) == 1:
        print(H*W//2 + 1)
    else:
        print(H*W//2)
//  [python]
H, W = map(int, input().split())

if H == 1 or W == 1:
	print(1)
else:
	if H * W % 2 == 0:
		print(H * W // 2)
	else:
		print(H * W // 2 + 1)
//  [python]
H,W=map(int,input().split())
print(((W+1)//2)*((H+1)//2)+(H//2)*(W//2) if H!=1 and W!=1 else 1)
//  [python]
h, w = map(int, input().split())

ans = h*w
if h == 1 or w == 1:
  print(0)
else:
  if ans%2 == 0:
    print(ans//2)
  else:
    print(ans//2+1)
//  [python]
h, w = map(int, input().split())

ans = h*w
if ans%2 == 0:
  print(ans//2)
else:
  print(ans//2+1)
//  [python]
h, w = list(map(int, input().split()))

if h % 2 == 0 or w % 2 == 0:
    print(int(w*h//2))
else:
    print(int((w*h)//2+1))
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.lang.*;


public class Main{
	static final long MOD = 1000000007;
	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		long h = sc.nextLong();
		long w = sc.nextLong();
		if (h == 1 || w == 1) {
			System.out.println(1);
			return;
		}
		System.out.println(((w + 1) / 2) * ((h + 1) / 2) + (w / 2) * (h / 2));
	}
}

class FastScanner {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;
	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}
	private int readByte() {
		if (hasNextByte()) {
			return buffer[ptr++];
		} else {
			return -1;
		}
	}
	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}
	public boolean hasNext() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr])) {
			ptr++;
		}
		return hasNextByte();
	}
	public String next() {
		if (!hasNext()) {
			throw new NoSuchElementException();
		}
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}
	public long nextLong() {
		if (!hasNext()) {
			throw new NoSuchElementException();
		}
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}
	public int nextInt() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || Integer.MAX_VALUE < nl) {
			throw new NumberFormatException();
		}
		return (int) nl;
	}
	public double nextDouble() {
		return Double.parseDouble(next());
	}
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.NoSuchElementException;

class Main {
	public static void main(String[] args) {
		new Main().run();
	}
	
	void run() {
		FastScanner sc=new FastScanner();
		long H=sc.nextLong();
		long W=sc.nextLong();
		if(H>W) {
			H^=W;W^=H;H^=W;
		}
		if(H!=1) {
			System.out.println(((W+1)/2)*((H+1)/2)+(W/2)*(H/2));
		}else {
			System.out.println(1);
		}
	}
	
	void tr(Object...objects) {System.out.println(Arrays.deepToString(objects));}
}


class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        }else{
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
    private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
    public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while(true){
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            }else if(b == -1 || !isPrintableChar(b)){
                return minus ? -n : n;
            }else{
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() { return Double.parseDouble(next());}
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {

  public static void main(String[] args) {
    FastScanner sc = new FastScanner();

    long H = sc.nextLong();
    long W = sc.nextLong();

    long ans = 0;

    if (H != 1 && W != 1) {
      if (W % 2 == 0) {
        ans = H * W / 2l;
      } else {
        ans = (H * (W + 1) / 2l) - H / 2;
      }
    } else {
      ans = 1;
    }

    System.out.println(ans);

  }
}

class FastScanner {
  private final InputStream in = System.in;
  private final byte[] buffer = new byte[1024];
  private int ptr = 0;
  private int buflen = 0;

  private boolean hasNextByte() {
    if (ptr < buflen) {
      return true;
    } else {
      ptr = 0;
      try {
        buflen = in.read(buffer);
      } catch (IOException e) {
        e.printStackTrace();
      }
      if (buflen <= 0) {
        return false;
      }
    }
    return true;
  }

  private int readByte() {
    if (hasNextByte()) {
      return buffer[ptr++];
    } else {
      return -1;
    }
  }

  private static boolean isPrintableChar(int c) {
    return 33 <= c && c <= 126;
  }

  private void skipUnprintable() {
    while (hasNextByte() && !isPrintableChar(buffer[ptr])) {
      ptr++;
    }
  }

  public boolean hasNext() {
    skipUnprintable();
    return hasNextByte();
  }

  public String next() {
    if (!hasNext()) {
      throw new NoSuchElementException();
    }
    StringBuilder sb = new StringBuilder();
    int b = readByte();
    while (isPrintableChar(b)) {
      sb.appendCodePoint(b);
      b = readByte();
    }
    return sb.toString();
  }

  public int nextInt() {
    if (!hasNext()) {
      throw new NoSuchElementException();
    }
    int n = 0;
    boolean minus = false;
    int b = readByte();
    if (b == '-') {
      minus = true;
      b = readByte();
    }
    if (b < '0' || '9' < b) {
      throw new NumberFormatException();
    }
    while (true) {
      if ('0' <= b && b <= '9') {
        n *= 10;
        n += b - '0';
      } else if (b == -1 || !isPrintableChar(b)) {
        return minus ? -n : n;
      } else {
        throw new NumberFormatException();
      }
      b = readByte();
    }
  }

  public long nextLong() {
    if (!hasNext()) {
      throw new NoSuchElementException();
    }
    long n = 0;
    boolean minus = false;
    int b = readByte();
    if (b == '-') {
      minus = true;
      b = readByte();
    }
    if (b < '0' || '9' < b) {
      throw new NumberFormatException();
    }
    while (true) {
      if ('0' <= b && b <= '9') {
        n *= 10;
        n += b - '0';
      } else if (b == -1 || !isPrintableChar(b)) {
        return minus ? -n : n;
      } else {
        throw new NumberFormatException();
      }
      b = readByte();
    }
  }
}
//  [java]
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        double h = sc.nextInt();
        double w = sc.nextInt();
        double ans = (double)h/2.0*w;
        
        //System.out.println(a);
        if(h%2==1){
            ans+=1;
        //System.out.println((int)ans);
        }
        
        System.out.println((int)ans);
    }
}
//  [java]
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        long h = sc.nextInt();
        long w = sc.nextInt();
        
        long ans = h/2*w;
        if(h%2==1){
            ans+=1;
        }
        
        System.out.println(ans);
    }
}
//  [java]
package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long h = in.nextLong();
        long w = in.nextLong();

        long hw = h*w;
        long hw2 = h*w/2;

        System.out.println(w==1 || h==1 ? 1 : hw2 + hw % 2);
    }
}
//  [cpp]
#include <stdio.h>

int main() {
long w=1;
long h=1;
scanf("%ld %ld",&w,&h);
if (w==1 || h==1)
printf("1");
else
printf("%ld",(w/2+w%2)*(h/2+h%2)+(w/2)*(h/2));
return 0;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef long int li;
typedef long double lb;
#define rep(i,j,n) for (ll i = j; i < (n); i++)
#define repr(i,j,n) for(ll i = j; i >= (n); i--)
#define all(x) (x).begin(),(x).end()
#define CLR(mat,f) memset(mat, f, sizeof(mat))
#define IN(a, b, x) (a<=x&&x<b)
#define out(ans) cout << ans << endl
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
typedef pair<ll,ll>P;
const ll mod=1e9+7;
const ll INF = 1LL<<60;
const ll m=1LL<<32;

int main(){

  ll h,w;cin>>h>>w;

  if(h==1||w==1)out(1);
  else{
    if(h%2==0&&w%2==0){
    out(h*w/2);
    }else if(h%2==0){
      out(h/2*w);
    }else if(w%2==0){
      out(w/2*h);
    }else out(h*(w/2)+(h+1)/2);
  }

  // out(((w+1)/2)*(h+1)/2+(w/2)*(h/2));
  // out(w/2*h+(w/2)*(h+1)/2);



  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
typedef long long int  ll;
const ll mod = 1e9+7;
#define rep(i,a,b) for(ll i=a;i<b;i++)

void swap(ll &a , ll &b){
    ll t = a;
    a = b;
    b = t;
}

ll min(ll a, ll b){
    if(a<b)return a;
    return b;
}

ll max(ll a, ll b){
    if(a>b)return a;
    return b;
}

 ll pow(ll a, ll b) {
    a %= mod;
    ll ans = 1;
    while (b > 0) {
        if (b & 1)
            ans = ans * a % mod;
        a = a * a % mod;
        b /= 2;
    }
    return ans;
}




int main(){

   ios_base :: sync_with_stdio(0);
   cin.tie(0);
   ll h,w;
   cin>>h>>w;
    if(h == 1 || w == 1){
        cout<<"1";
        return 0;
    }
   ll col;
   col = w/2;
   if(w&1){
    col++;
   }
   ll row = h/2;
   if(h&1){
    row++;
   }

   ll col1 = w/2;
   //ll row = ceil(h/2);
   ll row1 = h/2;
   //cout<<"col = "<<col<<" row = "<<row<<endl;
   ll ans= col*row+col1*row1;
   cout<<ans;

}
//  [cpp]
#include <iostream>

using namespace std;
typedef long long ll;

int main(void){
  ll H,W;
cin >> H >> W;

cout << (H * W + 1) / 2 << endl;

return 0; }
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define vi vector<int>
#define vb vector<bool>
#define pii pair<int,int>
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*b)/gcd(a,b)
#define F first
#define S second
#define inf (long long) 1e18
#define f(i,n)  for(int i=0;i<n;i++)
#define f(i,n) for(int i=n-1;i>=0;i--)
#define f(i,n) for(int i=1;i<=n;i++)

const int MOD = 1e9 + 7;

void solve()
{
    ll h,w;
    cin >> h >> w;
        cout << (h*w+1)/2 << "\n";

}


int main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int t=1;
  //cin>>t;
  while(t--)
  {
      solve();
  }
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define vi vector<int>
#define vb vector<bool>
#define pii pair<int,int>
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*b)/gcd(a,b)
#define F first
#define S second
#define inf (long long) 1e18
#define f(i,n)  for(int i=0;i<n;i++)
#define f(i,n) for(int i=n-1;i>=0;i--)
#define f(i,n) for(int i=1;i<=n;i++)

const int MOD = 1e9 + 7;

void solve()
{
    ll h,w;
    cin >> h >> w;
        cout << (h*w+1)/2;

}


int main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int t=1;
  //cin>>t;
  while(t--)
  {
      solve();
  }
}
//  [c]
#include <stdio.h>

int main(){
	long long h, w;
	scanf("%lld%lld",&h,&w);
	if((h==1)||(w==1)) printf("1\n");
	else if(h%2==0) printf("%lld\n",h*w/2);
	else if(w%2==0) printf("%lld\n",h*w/2);
	else printf("%lld\n",((h/2+1)+(h/2))*(w-1)/2+h/2+1);
}
//  [c]
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<stdint.h>
int main(){
  int x,y;
  scanf("%d %d", &x, &y);
  if(x != 1 && y != 1)
	  printf("%lld", (uint64_t)((uint64_t)ceil(x/2.0) * (uint64_t)ceil(y/2.0) + (uint64_t)floor(x/2.0) * (uint64_t)floor(y/2.0)));
  else
	  puts("1");
}
//  [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;

  return;
}


int gcd(int a, int b){
  int c;

  while (b > 0){
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

long int modpow(long int a,long int n,long int mod){
  long int ans=1;
  while(n>0){
    if(n & 1){
      ans=ans*a%mod;
    }
    a=a*a%mod;
    n/=2;
  }
  return ans;
}

long int modinv(long int a,long int mod){
  return modpow(a,mod-2,mod);
}

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){
  long int h,w;
  scanf("%ld%ld",&h,&w);
  long int ans=0;
  if(h%2!=0&&w%2!=0){
    ans+=(h*w+1)/2;
  }else{
    ans+=h*w/2;
  }
  printf("%ld\n",ans);
  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;

  return;
}


int gcd(int a, int b){
  int c;

  while (b > 0){
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

long int modpow(long int a,long int n,long int mod){
  long int ans=1;
  while(n>0){
    if(n & 1){
      ans=ans*a%mod;
    }
    a=a*a%mod;
    n/=2;
  }
  return ans;
}

long int modinv(long int a,long int mod){
  return modpow(a,mod-2,mod);
}

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){
  long int h,w;
  scanf("%ld%ld",&h,&w);
  long int odd=0,even=0;
  if(h%2==0){
    odd=h/2;
    even=h/2;
  }else{
    odd=(h+1)/2;
    even=h/2;
  }
  long int ans=0;
  ans+=(w/2)*odd+(w/2)*even;
  if(w%2==1){
    ans+=odd;
  }
  printf("%ld\n",ans);
  return 0;
}
//  [c]
#include <stdio.h>
int main(){
  long long int h,w;
  scanf("%lld %lld",&h,&w);
  if(h==1||w==1)
    printf("0\n");
  else if((h*w)%2==0)
    printf("%lld\n",(h*w)/2);
  else
    printf("%lld\n",(w*h)/2+1);
  return 0;
}
//  [javascript]
function Main(arg)
{
  var H = arg.split("\n")[0].split(" ")[0]-0;
  var W = arg.split("\n")[0].split(" ")[1]-0;

  var f = true;
  var ans = 0;
  
  if(H===1 || W===1){
    console.log(1);
    return;
  }

  if (H % 2 == 0) {
    console.log((H * W) / 2);
  }
  else {
    console.log(W * (H - 1) / 2 + Math.ceil(W / 2));
  }

  return;
}

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

const Main = (input) => {
  const tmp = input.trim().split(' ')
  const H = parseInt(tmp[0])
  const W = parseInt(tmp[1])

  let result = 0

  if (H === 1 || W === 1) {
    result = 1
  } else {
    result = Math.ceil(H * W / 2)
  }

  console.log(result)
  return result
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function Main(input) {
  var s = input.split(" ");
  var h = parseInt(s[0],10);
  var w = parseInt(s[1], 10);
  var r = h * w;
 
  if(h === 1 || w === 1){
    console.log("1");
    return;
  }
  
  // 偶数
  if(r % 2 === 0) {
    console.log(r/2);
  } else {
    // 奇数
    var a = r/2;
    console.log(Math.ceil(a));
  }
}
 
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));