jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.io.*;
import java.util.*;

public class Main {
	
	static long[] sumLengthOfDigitNumber = new long[19];
	static long[] digit10 = new long[19];
				
	public static void main(String[] args) throws IOException {
		FastScanner sc = new FastScanner(System.in);
		
		int AB = sc.nextInt();
		int BC = sc.nextInt();
		int CA = sc.nextInt();
		System.out.println(AB*BC/2);
		
	}//end main
	
}//end Main

class FastScanner {
    private InputStream in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    public FastScanner(InputStream in) {
		this.in = in;
	}
    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.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String[] str = in.readLine().split(" ");
    int ab = Integer.parseInt(str[0]);
    int bc = Integer.parseInt(str[1]);
    int ca = Integer.parseInt(str[2]);
    if(ab>=bc && ab>=ca)
      System.out.println(bc*ca/2);
    else if(bc>=ab && bc>=ca)
      System.out.println(ab*ca/2);
    else if(ca>=ab && ca>=bc)
      System.out.println(ab*bc/2);
  }
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.lang.Math;

public class Main {
    public static void main(String[] args) {
        FS reader = new FS();
        // write reader
        int[] a = new int[3];
        for (int i=0; i<3; i++) {
            a[i] = reader.nextInt();
        }
        Arrays.sort(a);

        System.out.println(a[0]*a[1]/2);
    }
    
    public static void solver() {
        // write logic
    }
    
    // Read Class
    static class FS {
        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() { return hasNextByte() ? buffer[ptr++] : -1;}
        private 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() {
            return (int)nextLong();
        }
        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.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int ans = a * b / 2;
		System.out.println(ans);

		
	}

}
//  [java]
import java.util.Scanner;
public class Main {

	public static void main(String[] args){
		Scanner stdIn=new Scanner(System.in);
		int A=stdIn.nextInt();
		int B=stdIn.nextInt();
		int C=stdIn.nextInt();
		System.out.println((A*B)/2);
	}
}
//  [java]
import java.util.*;
import java.io.*;

/*
   AtCoder contest code
   coder : yoichidon
 */
import java.util.*;
import java.io.*;

public class Main {
    public static long sum(long[] array){
        long ans = 0;
        for(long e:array) ans+=e;
        return ans;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double a = sc.nextDouble();
        double b = sc.nextDouble();
        double c = sc.nextDouble();
        double s = (a+b+c)/2;
        double area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
        System.out.println(Math.round(area));



    }
}
//  [cpp]
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
using namespace std;
const long long mod=1000000007;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const long double EPS=1e-9;
const long double PI=acos(-1.0);
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
long double ABS(long double a){return max(a,-a);}

int main(){
	int a,b;scanf("%d%d",&a,&b);printf("%d\n",a*b/2);
}
//  [cpp]
/* 
	Author: ankrypt
*/


#include <bits/stdc++.h>

using namespace std;

#define MOD 1000000007
#define ll long long int
#define u64 unsigned long long int

ll A, B, C;
ll ans;

int main() {
	scanf("%lld %lld %lld", &A, &B, &C);
	ans = (A * B) / 2;
	printf("%lld\n", ans);
	return 0;
}
/*
	Powered by Buggy Plugin
*/
//  [cpp]
#include <iostream>
using namespace std;

int main() {
  int a, b;
  cin >> a >> b;
  cout << a * b / 2 << endl;
  return 0;
}
//  [cpp]
// ABC116
// A - Right Triangle
#include<bits/stdc++.h>

using namespace std;

int main(){
    int ab,bc,ca;
    cin >> ab >> bc >> ca;
    cout << ab*bc/2 << endl;
    return 0;
}
//  [cpp]
#include <iostream>

using namespace std;

int main(){
  int x, y, z, ans;
  cin >> x >> y >> z;
  ans = (x*y)/2;
  cout << ans <<endl;
  return 0; 
}
//  [cpp]
#include <bits/stdc++.h>
#define pb push_back
#define Int long long
using namespace std;

const int MAXN=500005;
const long MOD=(long)(1e9+7);
vector<int> adj[MAXN];
vector<pair<int,int>> G[MAXN];

Int N,M,K;
Int B,C,H,W;
Int X,Y,Z;
vector<Int> A;

Int ceilS(Int x,Int y){
    return (x+y-1)/y;
}
using D=long double;

Int perform(Int x){
    return (x*(x+1))/2LL;
}

D getExpectation(D x) {
   return perform(x)/x;
}

int main()
{
    cin>>N>>M>>K;
    Int ans=(N*M)/2;
    cout<<ans<<"\n";
   
    
}
//  [c]
#include <stdio.h>
int main(){
    int a,b,c;
    scanf("%d %d %d",&a,&b,&c);
    printf("%d\n",(a*b)/2);
    return 0;
}
//  [c]
#include<stdio.h>

int main(void){
	int a, b, c;
	
	scanf("%d%d%d", &a, &b, &c);
	
	printf("%d", a * b / 2);
	
	return 0;
}
//  [c]
#include <stdio.h>
int main(void){
    // Your code here!
    int a,b;
    scanf("%d %d",&a,&b);
    printf("%d\n",(a*b)/2);
    return 0;
}
//  [c]
#include<stdio.h>

int main(void){
  
  int ab,bc,ca;
  int s;
  scanf("%d %d %d",&ab,&bc,&ca);
  
  s = (ab * bc) / 2;
  
  printf("%d",s);
  return 0;
}
//  [c]
#include <stdio.h>

int main () {
    int ab = 0;
    int bc = 0;
    int ca = 0;
    int area = 0;
    
  
    scanf("%d %d %d", &ab, &bc, &ca);

    
    area = ((ab*bc)/2);
    
    printf("%d\n", area);
    
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int AB,BC,CA,x;
    scanf("%d%d%d",&AB,&BC,&CA);
    x=0.5*BC*AB;
    printf("%d\n",x);
    return 0;
}
//  [javascript]
"use strict"
function Main(stdin){
stdin = stdin.trim().split("\n").reverse();
let stdout = [];
function input(){return stdin.pop()};
function print(x){stdout.push(x)};
function mapint(x){return x.map(n=>parseInt(n))};
function mapfloat(x){return x.map(n=>parseFloat(n))};
function max(x){return x.reduce(function(a,b){ return Math.max(a,b) }) }
function min(x){return x.reduce(function(a,b){ return Math.min(a,b) }) }
function sum(x){return x.reduce(function(a,b){ return a+b }) }
function sorting(x, index){x.sort((a, b) => a[index] - b[index])}
function all(x){return x.reduce(function(a,b){ return a && b }) }
function any(x){return x.reduce(function(a,b){ return a || b }) }
function inlist(x, xs){return xs.includes(x)}
function inset(x, xs){return xs.has(x)}
function list(iterable){return Array.from(iterable)}
function arrayint(iterable){return Array.from(iterable, x => parseInt(x))}
function tile(val, len){return Array(len).fill(val)}
for (let i = 0; i < 10; i++){ break; }
const range = (start, stop, step) => Array.from(
    { length: (stop - start) / step }, (_, i) => start + (i * step));
/*START*/


let tmp = mapint(input().split(" "))
print(tmp[0] * tmp[1] / 2)


/*END*/
stdout = stdout.join("\n");
console.log(stdout);
return stdout
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [javascript]
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
	tmp = input[0].split(" ");
	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(tmp[0], 10);
	var b = parseInt(tmp[1], 10);
    var c = parseInt(tmp[2], 10);
     total= a*b/2;
    console.log(total);
	
	
	
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]

function main(input){
    abc=input.split(' ');
    //console.log(abc)
    ab=parseInt(abc[0],10)
    bc=parseInt(abc[1],10)
    console.log(ab*bc/2)
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
const input = require('fs').readFileSync('/dev/stdin', 'utf8').split(" ");
console.log(parseInt(input[0]) * parseInt(input[1]) / 2);
//  [javascript]
function Main(input) {
  input = input.split("\n");
  var A = parseInt(input[0].split(" ")[0]);
  var B = parseInt(input[0].split(" ")[1]);
  var C = parseInt(input[0].split(" ")[2]);
  var ans = A*B/2;

  console.log('%s', ans);
}
  
// "実行する"ボタンを押した時に実行される関数 (デバッグ用)
function debug(){
  var input = document.getElementById("input").value;
  Main(input);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function main(input) {
  var lines = input.split('\n');
  var hs = splitNum(lines[0]).slice(0, 3);
  hs.sort(function (a, b) {
    return a - b;
  });
  console.log(hs[0] * hs[1] / 2);
}

var P = 1e9 + 7;
main(require('fs').readFileSync('/dev/stdin', 'utf8'));

function splitNum(line) {
  return (Array.isArray(line) ? line : line.split(/\s+/)).map(function (n) {
    return parseInt(n);
  });
}
/**
 * Iterates over integers in [start, end).
 */


function* range(start, end) {
  for (var i = start; i < end; i++) {
    yield i;
  }
}
/**
 * Iterates over integers in [end, start) in desc order.
 */


function* rangeRev(start, end) {
  for (var i = start - 1; i >= end; i--) {
    yield i;
  }
}
/**
 * Runs a recursive function expressed as a generator function.
 */


function runRecursive(func) {
  // 最終結果を受け取るオブジェクトを用意
  var rootCaller = {
    lastReturnValue: null
  }; // 自前のコールスタックを用意

  var callStack = []; // 最初の関数呼び出しを追加

  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }

  callStack.push({
    iterator: func.apply(void 0, args),
    lastReturnValue: null,
    caller: rootCaller
  });

  while (callStack.length > 0) {
    var stackFrame = callStack[callStack.length - 1];
    var iterator = stackFrame.iterator,
        lastReturnValue = stackFrame.lastReturnValue,
        caller = stackFrame.caller; // 関数の実行を再開

    var _iterator$next = iterator.next(lastReturnValue),
        value = _iterator$next.value,
        done = _iterator$next.done;

    if (done) {
      // 関数がreturnしたので親に返り値を記録
      caller.lastReturnValue = value;
      callStack.pop();
    } else {
      // 関数がyieldした（valueは再帰呼び出しの引数リスト）
      callStack.push({
        iterator: func.apply(void 0, _toConsumableArray(value)),
        lastReturnValue: null,
        caller: stackFrame
      });
    }
  }

  return rootCaller.lastReturnValue;
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var c, a, b int
  fmt.Scan(&c, &a, &b)
  fmt.Println(c * a / 2)
}
//  [go]
package main

import "fmt"

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

	fmt.Println(a * b / 2)
}
//  [go]
package main
 
import (
	"fmt"
)
 
func main() {
  var ab, bc, ca int
  fmt.Scanf("%d %d %d", &ab, &bc, &ca)

  ans := (ab * bc) / 2
  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

func main() {
	mod = 1000000007
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	c, b, _ := intScanner(), intScanner(), intScanner()
	fmt.Println(c * b / 2)
}
//  [go]
package main

import (
	"fmt"
)

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

	fmt.Println((a * b) / 2)
}
//  [ruby]
a,b,c = gets.split.map(&:to_i)
puts a * b / 2
//  [ruby]
ab, bc, ca = gets.chomp.split.map(&:to_i)

ans = ab * bc / 2

puts ans
//  [ruby]
l = gets.chomp.split.map(&:to_i).sort!
puts l[0] * l[1] / 2
//  [ruby]
ab, bc, ca = gets().chomp.split("\s").map{|x| x.to_i}

list = [ab, bc, ca].sort

puts list[0] * list[1] / 2
//  [ruby]
#!/usr/bin/env ruby

require 'set'

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.chomp.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

AB, BC, CA = get_ints


puts (AB * BC) / 2
//  [ruby]
edges = gets.chomp.split(' ').map(&:to_i)
puts edges[0]*edges[1]/2
//  [rust]
use std::io;
use std::str::FromStr;
use std::cmp::max;

fn input_tuple() -> (u64, u64, u64) {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    let vec: Vec<u64> = line.split_whitespace().map(|s| s.parse().unwrap()).collect();
    (vec[0], vec[1], vec[2])
}

fn main() {
    let (a, b, c) = input_tuple();
    let max_dist = max(max(a, b), c);
    if a == max_dist {
        println!("{}", b * c / 2);
    } else if b == max_dist {
        println!("{}", a * c / 2);
    } else {
        println!("{}", a * b / 2);
    }
}
//  [rust]
use std::io::*;//Not mine.
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 a:i32 = read();
    let b:i32 = read();
    let c:i32 = read();
    println!("{}",a * b * c / std::cmp::max(a,std::cmp::max(b,c)) / 2);
}
//  [rust]
use std::io;

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

fn main() {
	let v: Vec<i32> = procon_read();
	let ab = v[0];
	let bc = v[1];
	println!("{}", ab*bc/2);
}
//  [rust]
// use proconio::marker::Chars;
use proconio::{fastout, input};
// use std::cmp::{max, min};

#[fastout]
fn main() {
    input! {
        l: [usize; 3]
    };

    let mut l = l;
    l.sort();

    println!("{}", l[0] * l[1] / 2);
}
//  [rust]
use proconio::input;

fn main (){

let mut _ab : f64;
let mut _bc : f64;
let mut _ca : f64;

input! {
    ab : f64,
    bc : f64,
    ca : f64,

}

let ans : f64 = (bc/2.0)*ab ; 
//let ans_1 : i128 = ((bc/2)+1/2)*ab ; 
println!("{}",ans);
}
//  [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 ab: usize = iterator.next().unwrap().parse().unwrap();
    let bc: usize = iterator.next().unwrap().parse().unwrap();
    let _ca: usize = iterator.next().unwrap().parse().unwrap();

    let ans = ab * bc / 2;
    return ans.to_string();
}
//  [swift]
import Foundation

let input = readLine()!.componentsSeparatedByString(" ")
let AB = Int(input[0])!
let BC = Int(input[1])!

let ans = AB * BC / 2

print(ans)
//  [swift]
let cab: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
print(Int(cab[0]*cab[1]/2))
//  [swift]
import Foundation
let i = readLine()!.componentsSeparatedByString(" ")
print(Int(i[0])!*Int(i[1])!/2)
//  [swift]
import Foundation;let i=readLine()!.componentsSeparatedByString(" ");print(Int(i[0])!*Int(i[1])!/2)
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result}

const main = ()=>{
  out(nin()*nin()/2);
}
main();
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [ab, bc] = stdin.split('\n')[0].split(' ').map(Number)

const res = ab * bc / 2

console.log(res)
//  [typescript]
const funcA = (input: string): void => {
    const hoge: number[] = input.split(" ").map(Number);
    const fuga: number[] = hoge.slice().sort(
        (a: number, b: number): number => { return a-b; }
    );
    console.log((fuga[0]*fuga[1]) / 2);
}

funcA(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
namespace sample {
  class Scanner {
    private buffer: string = '';
    private stdinQueue: any = [];

    constructor() {
      process.stdin.resume();
      process.stdin.setEncoding('utf8');
      process.stdin.on(
        'data',
        (chunk): void => {
          this.buffer += chunk;
          while (this.stdinQueue.length > 0) {
            const i = this.buffer.indexOf('\n');
            if (i < 0) {
              break;
            }
            let line = this.buffer.substr(0, i);
            if (line.endsWith('\r')) {
              line = line.slice(0, -1);
            }
            this.buffer = this.buffer.substr(i + 1);
            this.stdinQueue.shift()(line);
          }
        },
      );
    }
    public getLine(): Promise<string> {
      return new Promise((resolve, reject) => {
        const i = this.buffer.indexOf('\n');
        if (i >= 0 && this.stdinQueue.length == 0) {
          let line = this.buffer.substr(0, i);
          if (line.endsWith('\r')) {
            line = line.slice(0, -1);
          }
          this.buffer = this.buffer.substr(i + 1);
          resolve(line);
        } else {
          this.stdinQueue.push(resolve);
        }
      });
    }

    public close(): void {
      process.stdin.pause();
    }
  }

  async function slove() {
    const sc = new Scanner();
    const [ab, bc, ca]: number[] = (await sc.getLine())
      .split(' ')
      .map((x) => +x);
    console.log((ab * bc) / 2);
    sc.close();
  }

  slove();
}
//  [typescript]
const solve = (input) => {
  const [ab, bc, ca] = input.split(" ").map(Number)
  return (ab * bc) / 2
}

if (process.env.NODE_ENV === "test") {
  module.exports = (input) => solve(input.trim())
} else {
  const input = require("fs").readFileSync("/dev/stdin", "utf8")
  console.log(solve(input.trim()))
}
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc116 {

    export class Program {
        /**
         * in
         *
         * out
         *
         */
        static main(inp: string): void {
            const inpList: number[] = inp.split(' ').map(x => parseInt(x, 10)).sort((a, b) => {
                return a - b
            });
            console.log(inpList[0] * inpList[1] / 2);
        }
    }
}

AtCoder.abc116.Program.main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [python]
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,k = map(int,readline().split())
A = list(map(int,readline().split()))

class SegmentTree:
    def __init__(self, n, ele, segfun):
        #####単位元######要設定0or1orinf
        self.ide_ele = ele
        self.segfun = segfun
        ####################
        self.n = n
        self.N0 = 1 << n.bit_length()
        self.data = [self.ide_ele] * (self.N0 * 2)
        
    def update_add(self, l, r, val):
        l += self.N0
        r += self.N0
        while l < r:
            if l & 1:
                self.data[l] += val
                l += 1
            if r & 1:
                self.data[r - 1] += val
                r -= 1
            l //= 2
            r //= 2

    def update(self, l, r, val):
        l += self.N0
        r += self.N0
        while l < r:
            if l & 1:
                self.data[l] = self.segfun(self.data[l], val)
                l += 1
            if r & 1:
                self.data[r - 1] = self.segfun(self.data[r - 1], val)
                r -= 1
            l //= 2
            r //= 2

    def query(self, i):
        i += len(self.data) // 2
        ret = self.data[i]
        while i > 0:
            i //= 2
            ret = self.segfun(ret, self.data[i])
        return ret

for i in range(k):
  m = n
  S = SegmentTree(n,0,lambda a, b: a+b)
  for j in range(n):
    q = A[j]
    m = min(m,q)
    S.update_add(max(1,j-q+1),min(n+1,j+q+2), 1)
  if i < k-1 and m >= n-1:
    A = [n]*n
    break
  for l in range(n):
    p = S.query(l+1)
    A[l] = p
    
print(*A)
//  [python]
import sys
from itertools import accumulate
input=sys.stdin.buffer.readline

def main():
    n, k = map(int, input().split())
    A = [*map(int, input().split())]
    
    # for _ in range(min(k,int(math.log(n,2)))):
    
    for _ in "_"*k:
        b=[0]*(n)
        
        for i,v in enumerate(A):
            if i>v:
            # b[max(0,i-v)]+=1
                b[i-v]+=1
            else:
                b[0]+=1
            j=i-~v
            # if i+v+1<n:
            #     b[i+v+1]-=1
            if j<n:
                b[j]-=1
        
        # update ans
        # cnt=0
        # for i in range(1,n):
        #     b[i]+=b[i-1]
        A=[*accumulate(b)]
        
        if min(A)==n:
            break
    print(" ".join(map(str,A)))

if '__main__' == __name__:
    main()
//  [python]
N, K = map(int, input().split())
A = list(map(int, input().split()))

for i in range(K):
  R = [ {} for j in range(N)]

  for j in range(N):
    s = A[j]
    # j - s ~ j + s
    if min(j+s, N-1) in R[max(0, j-s)]:
      R[max(0, j-s)][min(j+s, N-1)] += 1
    else:
      R[max(0, j-s)][min(j+s, N-1)] = 1
        
  # Make Next List
  #print(R)
  L = [0 for j in range(N)]
  t = 0
  for j in range(N):
    r = R[j]
    for k, v in r.items():
      t += v
      L[k] += v
    A[j] = t
    t -= L[j]
    
  if A[0] == N and A[-1] == N:
    for j in range(N):
      if A[j] < N:
        break
    else:
      break
print(*A)
//  [java]
	import java.util.*;
	import java.util.Map.Entry;
	 
	 
	 class Main {
		 static int mod =  (int) (Math.pow(10,9)+7);
//		 static int mod =  (int) 998244353;
		 public static void main(String[] args) {
	    	
	        Scanner sc = new Scanner(System.in);

	        int N = sc.nextInt();
	        int K = sc.nextInt();
	        int[][] m = new int[1005][N+5];
	        for (int i=0 ; i<N; i++) {
	        	int tmp= Integer.parseInt(sc.next());
	            m[0][Math.max(0,i)]+=tmp;
	            m[0][Math.min(N,i+1)]-=tmp;
	        }
	        
    		int tmp=0;
	        for(int i=1;i<=Math.min(K, 100);i++) {
	        	for(int j=0;j<N;j++) {
	        		if(j==0) {
	        			tmp=m[i-1][0];
	        		} else {
	        			tmp=tmp+m[i-1][j];
	        		}
		        	m[i][Math.max(0,j-tmp)]++;	        		
		        	m[i][Math.min(N,j+tmp)+1]--;	        		
	        	}
	        }
	        int[] ans = new int[N];
	        ans[0]=m[Math.min(K, 100)][0];
	        System.out.print(ans[0]);
	        if(N!=1)System.out.print(" ");
	        for(int i=1;i<N;i++) {
	        	ans[i]=ans[i-1]+m[Math.min(K, 100)][i];
	        	System.out.print(ans[i]);
	        	if(i==N-1) {
	        		System.out.println();
	        	} else {
	        		System.out.print(" ");
	        	}
	        }
	        
	       
	    }
	}
//  [java]
import java.util.*;

public class Main {
    static int gcd (int x,int y) {return y>0?gcd(y,x%y):x;}
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int K = sc.nextInt();
        int A[] = new int[N+1];
        for(int i=1; i<=N; i++) {
            A[i] = sc.nextInt();
        }

        for(int i=1; i<=Math.min(K, 42); i++) {
            int T[] = new int[N+2];
            for(int k=1; k<=N; k++) {
                int leftIndex = Math.max(1, k-A[k]);
                int rightIndex = Math.min(N+1, k+A[k]+1);
                T[leftIndex] += 1;
                T[rightIndex] -= 1;
            }
            int B[] = new int[N+1];
            for(int k=1; k<=N; k++) {
                B[k] = B[k-1] + T[k];
            }
            A = B;
        }
        dump(A, N);
    }

    static void dump(int[] array, int size) {
        for(int i=1; i<=size; i++) {
            if(i!=1) System.out.print(" ");
            System.out.print(String.format("%d", array[i]));
        }
        System.out.println();
    }
}
//  [java]

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        Scanner scn = new Scanner(System.in);
        int N = scn.nextInt();
        int K = scn.nextInt();
        int[] A = new int[N];
        int[] B = new int[N];

        for (int i = 0; i < N; i++) {
            A[i] = scn.nextInt();
        }

        for(int i=0;i<Math.min(K,42);i++) {

            Arrays.fill(B,0);

            for (int i2 = 0; i2 < N; i2++) {
                int t = A[i2];
                int d1 = i2 - t;
                int d2 = i2 + t;
                if (d1 < 0) {
                    d1 = 0;
                }
                B[d1]+=1;
                if (d2 < N-1) {
                    B[d2+1]-=1;
                }
            }
            for(int i3=1;i3<N;i3++){
                B[i3]+=B[i3-1];
            }
            A=B.clone();


        }



        System.out.printf("%d",A[0]);
        for(int i=1;i<N;i++){
            System.out.printf(" %d",A[i]);
        }
        System.out.printf("%n");

        scn.close();

    }

}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  int N, K;
  cin >> N >> K;

  vector<int> A(N);
  for (int i = 0; i < N; ++i) {
    cin >> A[i];
  }

  auto f = [](vector<int> a) {
    const int n = a.size();
    vector<int> b(n, 1);
    multiset<int> bag;
    for (int i = 0; i < n; ++i) {
      while (bag.size() && *bag.begin() < i) bag.erase(bag.begin());
      b[i] += bag.size();
      bag.insert(i + a[i]);
    }
    bag.clear();
    for (int i = n - 1; ~i; --i) {
      while (bag.size() && *--bag.end() > i) bag.erase(--bag.end());
      b[i] += bag.size();
      bag.insert(i - a[i]);
    }
    return b;
  };

  for (int i = 0; i < K; ++i) {
    A = f(A);
    if (all_of(A.begin(), A.end(), [&](int v) { return v == N; })) {
      // cerr << i + 1 << endl;
      break;
    }
  }

  for (int j = 0; j < N; ++j) {
    cout << A[j] << " \n"[j + 1 == N];
  }

  return 0;
}
//  [cpp]
#include "bits/stdc++.h"
using namespace std;

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)   FOR(i,0,n)
#define LL long long

const int MAXSSTN = 200010;
class StarrySkyTree{
public:
  int size=0;
  int depth=0; // the depth of the tree
  int best=0;  // the index of maximum element
  int start=0; // the initial index of inputs
  long long dat_add[4 * MAXSSTN];
  long long dat[4 * MAXSSTN];
  
  StarrySkyTree(int n){
    size=n;
    while((1<<depth)<n)depth++;
    start=(1<<depth)-1;
    for(int i=start;i<(1<<(depth+1));i++){
      if(i<start+n)
	dat[i]=0;
      else
	dat[i]=1e15;
    }
    for(int i=start;i<start+n;i++){
      int tmp=i;
      while(par(tmp)!=-1){
	dat[par(tmp)]=min(dat[tmp],dat[(tmp+1)/2*4-1-tmp]);
	tmp=par(tmp);
      }
    }
    int i=0;
    while(i<start)i=(dat[i]==dat[2*i+1])?2*i+1:2*i+2;
    best=i-start;
  }
  long long max_element(int a, int b){ return max_element(a, b, 0, 0, (1<<depth)); }
  void add(int s, int t, int x){ add(s, t, 0, 0, (1<<depth), x); }
  void add(int i, int x){ add(i, i + 1, 0, 0, (1<<depth), x); }

  int par(int i){
    if(i==0)
      return -1;
    return (i-1)/2;
  }
  
  void clear() {
    for(int i=start;i<(1<<(depth+1));i++){
      if(i<start+size)
	dat[i]=0;
      else
	dat[i]=1e15;
    }
    for(int i=start;i<start+size;i++){
      int tmp=i;
      while(par(tmp)!=-1){
	dat[par(tmp)]=min(dat[tmp],dat[(tmp+1)/2*4-1-tmp]);
	tmp=par(tmp);
      }
    }
    int i=0;
    while(i<start)i=(dat[i]==dat[2*i+1])?2*i+1:2*i+2;
    best=i-start;
    
    REP(i,4*MAXSSTN)dat_add[i]=0;
  }

  void update(int d,long long x){
    int i=d+start;
    dat[i]=x;
    while(par(i)!=-1){
      dat[par(i)]=min(dat[i],dat[(i+1)/2*4-1-i]);
      i=par(i);
    }
    i=0;
    while(i<start){
      i=(dat[i]==dat[2*i+1])?2*i+1:2*i+2;
    }
    best=i-start;
  }
  void dump(){
    for(int i=0;i<(1<<(depth+1));i++){
      cerr<<dat[i]<<" ";
    }
    cerr<<endl;
  }
private:
  long long max_element(int a, int b, int k, int l, int r){
    if(b <= l || r <= a) return 1e15;
    if(a <= l && r <= b) return dat[k] + dat_add[k];

    long long vl = max_element(a, b, k * 2+1, l, (l + r) / 2);
    long long vr = max_element(a, b, k * 2+2, (l + r) / 2, r);
    return min(vl, vr) + dat_add[k];
  }
  void add(int a, int b, int k, int l, int r, long long x){
    if(b <= l || r <= a) return;
    if(a <= l && r <= b){
      dat_add[k] += x;
    }else{
      add(a, b, k * 2+1, l, (l + r) / 2, x);
      add(a, b, k * 2+2, (l + r) / 2, r, x);
      dat[k] = min(dat[k * 2+1] + dat_add[k * 2+1], dat[k * 2 + 2] + dat_add[k * 2 + 2]);
    }
  }
};

int n,k;
int a[200000];
 
int main(){
  cin>>n>>k;
  REP(i,n)cin>>a[i];
  if(k >= 41){
    REP(i,n)cout<<n<<" ";
    cout<<endl;
    return 0;
  }
 
  StarrySkyTree sst(n);
  REP(i,k){
    REP(j,n)sst.update(j,0);
    REP(j,n){
      sst.add(max(0,j-a[j]),min(n-1,j+a[j])+1,1);
    }
    REP(j,n){
      if(a[j]!=n || !i)
	      a[j]=sst.max_element(j,j+1);
    }
    sst.clear();
  }
 
  REP(i,n)cout<<a[i]<<" ";
  cout<<endl;
  return 0;
}
//  [c]
#include <stdio.h>

#define max(a, b) ((int)(a) > (int)(b) ? (a) : (b))
#define min(a, b) ((int)(a) > (int)(b) ? (b) : (a))

int main(void)
{
    int N, K;
    scanf("%d %d", &N, &K);

    int A[N + 1], lamp[N + 1];
    for(int i = 0; i < N; i++)
    {
        scanf("%d", &A[i]);
    }

    for(int i = 0; i < min(K, 50); i++)
    {
        for(int j = 0; j < N + 1; j++) { lamp[j] = 0; }
        for(int j = 0; j < N; j++)
        {
            lamp[max(0, j - A[j])] += 1;
            lamp[min(N, j + A[j] + 1)] -= 1;
        }

        for(int j = 1; j < N + 1; j++) { lamp[j] += lamp[j - 1]; }
        for(int j = 0; j < N + 1; j++) { A[j] = lamp[j]; }
    }

    for(int i = 0; i < N; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
int max(int a,int b){
  if(a>b) return a;
  return b;
}
int main(){
  int N,K,*cur,NN,*ans;
  scanf("%d %d",&N,&K);
  NN=N*N;
  cur=malloc(sizeof(int)*N);
  ans=malloc(sizeof(int)*N);
  for(int i=0;i<N;i++) scanf("%d",&cur[i]);
  for(int x=0;x<K;x++){
    int *nex,sum;
    sum=0;
    nex=malloc(sizeof(int)*N);
    for(int y=0;y<N;y++) nex[y]=0;
    for(int i=0;i<N;i++){
      int d,l,r;
      d=cur[i];
      l=max(0,i-d);
      r=i+d;
      nex[l]++;
      if(r+1<N) nex[r+1]--;
    }
    for(int i=1;i<N;i++) nex[i]+=nex[i-1];
    cur=nex;
    for(int i=0;i<N;i++) sum+=cur[i];
    if(sum==NN){
      printf("%d",cur[0]);
      for(int i=1;i<N;i++) printf(" %d",cur[i]);
      printf("\n");
      break;
    }
    if(x==K-1){
      printf("%d",cur[0]);
      for(int i=1;i<N;i++) printf(" %d",cur[i]);
      printf("\n");
    }
  }
  return 0;
}
//  [javascript]
"use strict";
var input = require("fs").readFileSync("/dev/stdin", "utf8");
var cin = input.split(/ |\n/),
    cid = 0;

function next() {
    return +cin[cid++];
} // number一個取得
function nextstr() {
    return cin[cid++];
} // 文字列一個取得
function nextbig() {
    return BigInt(cin[cid++]);
} // BigInteger一個取得
// 長さnの配列として取得。aは文字列フラグ
function nexts(n, a) {
    return a ? cin.slice(cid, cid += n) : cin.slice(cid, cid += n).map(a => +a);
}
// 長さnのBigInt配列として取得。
function nextsbig(n) {
    return cin.slice(cid, cid += n).map(a => BigInt(a));
}
// w個ずつを組にして長さhの配列。aは文字列フラグ。
function nextm(h, w, a) {
    var r = [],
        i = 0;
    if (a)
        for (; i < h; i++) r.push(cin.slice(cid, cid += w));
    else
        for (; i < h; i++) r.push(cin.slice(cid, cid += w).map(a => +a));
    return r;
}
// 多次元配列。v,a1,a2,a3 なら、3次元。[[値vで長さa3の配列]をa2個並べた配列]をa1個並べた配列。
function xArray(v) {
    var a = arguments,
        l = a.length,
        r = "Array(a[" + --l + "]).fill().map(x=>{return " + v + ";})";
    while (--l) r = "Array(a[" + l + "]).fill().map(x=>" + r + ")";
    return eval(r);
}

console.log(main());

function main() {
    let N = next();
    let K = next();
    let A = nexts(N);
    let t = xArray(0, N);
    let B = Array(N);
    let i, j, k, left, right;
    for (k = 0; k < K; k++) {
        left = xArray(0, N);
        right = xArray(0, N);
        for (i = 0; i < N; i++) {
            // 各Aiの電球が各点zahyoを照らしているかどうかをチェックする。
            left[Math.max(i + 1 - A[i], 1) - 1]++;
            right[Math.min(i + 1 + A[i], N) - 1]++;
        }
        //console.log({left,right});
        // 両端にすべての灯りが届いているかどうかをチェック。
        if (left[0] == N && right[N - 1] == N) {
            return xArray(N, N).join(" ");
        }
        A[0] = left[0];
        for (i = 1; i < N; i++) {
            A[i] = A[i - 1] + left[i] - right[i - 1];
        }
    }
    return A.join(" ");
}
//  [javascript]
"use strict";
var input = require("fs").readFileSync("/dev/stdin", "utf8");
var cin = input.split(/ |\n/),
    cid = 0;

function next() {
    return +cin[cid++];
} // number一個取得
function nextstr() {
    return cin[cid++];
} // 文字列一個取得
function nextbig() {
    return BigInt(cin[cid++]);
} // BigInteger一個取得
// 長さnの配列として取得。aは文字列フラグ
function nexts(n, a) {
    return a ? cin.slice(cid, cid += n) : cin.slice(cid, cid += n).map(a => +a);
}
// 長さnのBigInt配列として取得。
function nextsbig(n) {
    return cin.slice(cid, cid += n).map(a => BigInt(a));
}
// w個ずつを組にして長さhの配列。aは文字列フラグ。
function nextm(h, w, a) {
    var r = [],
        i = 0;
    if (a)
        for (; i < h; i++) r.push(cin.slice(cid, cid += w));
    else
        for (; i < h; i++) r.push(cin.slice(cid, cid += w).map(a => +a));
    return r;
}
// 多次元配列。v,a1,a2,a3 なら、3次元。[[値vで長さa3の配列]をa2個並べた配列]をa1個並べた配列。
function xArray(v) {
    var a = arguments,
        l = a.length,
        r = "Array(a[" + --l + "]).fill().map(x=>{return " + v + ";})";
    while (--l) r = "Array(a[" + l + "]).fill().map(x=>" + r + ")";
    return eval(r);
}

console.log(main());

function main() {
    let N = next();
    let K = next();
    let A = nexts(N);
    let i, k, left, right;
    for (k = 0; k < K; k++) {
        left = xArray(0, N);
        right = xArray(0, N);
        for (i = 0; i < N; i++) {
            // 各Aiの電球が照らす範囲の端の数を計算する。
            left[Math.max(i + 1 - A[i], 1) - 1]++;
            right[Math.min(i + 1 + A[i], N) - 1]++;
        }
        // 両端にすべての灯りが届いているかどうかをチェック。
        if (left[0] == N && right[N - 1] == N) {
            return xArray(N, N).join(" ");
        }
        // 各範囲の数を合計する。
        A[0] = left[0];
        for (i = 1; i < N; i++) {
            A[i] = A[i - 1] + left[i] - right[i - 1];
        }
    }
    return A.join(" ");
}
//  [javascript]
"use strict";
var input = require("fs").readFileSync("/dev/stdin", "utf8");
var cin = input.split(/ |\n/),
    cid = 0;

function next() {
    return +cin[cid++];
} // number一個取得
function nextstr() {
    return cin[cid++];
} // 文字列一個取得
function nextbig() {
    return BigInt(cin[cid++]);
} // BigInteger一個取得
// 長さnの配列として取得。aは文字列フラグ
function nexts(n, a) {
    return a ? cin.slice(cid, cid += n) : cin.slice(cid, cid += n).map(a => +a);
}
// 長さnのBigInt配列として取得。
function nextsbig(n) {
    return cin.slice(cid, cid += n).map(a => BigInt(a));
}
// w個ずつを組にして長さhの配列。aは文字列フラグ。
function nextm(h, w, a) {
    var r = [],
        i = 0;
    if (a)
        for (; i < h; i++) r.push(cin.slice(cid, cid += w));
    else
        for (; i < h; i++) r.push(cin.slice(cid, cid += w).map(a => +a));
    return r;
}
// 多次元配列。v,a1,a2,a3 なら、3次元。[[値vで長さa3の配列]をa2個並べた配列]をa1個並べた配列。
function xArray(v) {
    var a = arguments,
        l = a.length,
        r = "Array(a[" + --l + "]).fill().map(x=>{return " + v + ";})";
    while (--l) r = "Array(a[" + l + "]).fill().map(x=>" + r + ")";
    return eval(r);
}

console.log(main());

function main() {
    let N = next();
    let K = next();
    let A = nexts(N);
    let t = xArray(0, N);
    let B = Array(N);
    let i, j, k, left, right;
    for (k = 0; k < K; k++) {
        left = xArray(0, N);
        right = xArray(0, N);
        for (i = 0; i < N; i++) {
            // 各Aiの電球が照らす範囲の端の数を計算する。
            left[Math.max(i + 1 - A[i], 1) - 1]++;
            right[Math.min(i + 1 + A[i], N) - 1]++;
        }
        // 両端にすべての灯りが届いているかどうかをチェック。
        if (left[0] == N && right[N - 1] == N) {
            return xArray(N, N).join(" ");
        }
        // 各範囲の数を合計する。
        A[0] = left[0];
        for (i = 1; i < N; i++) {
            A[i] = A[i - 1] + left[i] - right[i - 1];
        }
    }
    return A.join(" ");
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)
var a,b []int
func main() {
	sc.Split(bufio.ScanWords)
	N := scanInt()
	K := scanInt()
	a = make([]int, N)
	for i:= 0; i<N; i++ {
		a[i] = scanInt()
	}
	// 前の状態とあとの状態を維持する必要がある
	if K > 500 {
		K = 500
	}
	for i:= 0; i<K; i++ {
		//愚直にやる -> 多分無理
		b = make([]int, N)
		mapNext := make([]int,N) //どこで-1なるか調べる
		count := 0
		for j := 0; j < N; j++ {
			//next方向
			light := a[j]
			if !(b[j] >= N) {
				b[j] += count+1
			}
			if light > 0 {
				count += 1
				if N > light + j {
					mapNext[light+j] += 1
				}
			}
			count -= mapNext[j]
		}
		mapPrev := make([]int,N)
		count = 0
		for j:= N-1; j>=0; j-- {
			light := a[j]
			if !(b[j] >= N) {
				b[j] += count
			}
			if light > 0 {
				count += 1
				if j - light >= 0 {
					mapPrev[j-light] +=1
				}
			}
			count -= mapPrev[j]
		}
		a = b
	}
	for i:= 0; i<N; i++ {
		fmt.Print(a[i])
		fmt.Print(" ")
	}
}
var sc = bufio.NewScanner(os.Stdin)
func scanInt () int{
	sc.Scan()
	i,_ := strconv.Atoi(sc.Text())
	return i
}
//  [ruby]
def gets_nums
    gets.split.map{|x| x.to_i}
end
def light(a,b,n)
    b.fill(0)
    0.upto(n-1) do |i|
        l = i-a[i]
        r = i+a[i]+1
        l = 0 if l < 0
        b[l]+=1
        b[r]-=1 if r < n
    end
    flag = a[0]==b[0]
    a[0] = b[0]
    1.upto(n-1) do |i|
        b[i] += b[i-1]
        flag &= (a[i]==b[i])
        a[i] = b[i]
    end
    return flag
end
n, k = gets_nums
a = gets_nums
b = Array::new(n+1)
0.upto(k-1) do |i|
    break if light(a,b,n)
end
puts a.join(" ")
//  [ruby]
#input of int(split by space)
def get_i()
  return gets.chomp.split(" ").map(&:to_i)
end
#input of float(split by space)
def get_f()
  return gets.chomp.split(" ").map(&:to_f)
end
#input of string(split by space)
def get()
  return gets.chomp.split(" ")
end
#input of string(split per one character)
def get_nsp()
  return gets.chomp.split("")
end
#yes or no decision
def yn_judge(bool,y="Yes",n="No")
  return bool ? y : n 
end
#create of array
def array(size1,init=nil,size2=-1)
  if size2==-1
    return Array.new(size1){init}
  else
    return Array.new(size2){Array.new(size1){init}}
  end
end

def max(a,b)
    return a>b ? a : b
end

def min(a,b)
    return a>b ? b : a
end

INF=Float::INFINITY

N,K=get_i
a=get_i
cnt=0
min(K,50).times do
  imos=[0]*N
  N.times do|i|
      imos[max(i-a[i],0)]+=1
      #imos[i]-=1
      #imos[min(i+1,N-1)]+=1
      imos[i+a[i]+1]-=1 if i+a[i]+1<N
  end
  #imos[N-1]-=1
  #p imos
  #accum=array(N+1,0)
  a[0]=imos[0]
  (N-1).times do|i|
      #accum[i+1]=accum[i]+imos[i]
      #a[i]=accum[i+1]
      a[i+1]=a[i]+imos[i+1]
  end
  cnt+=1
end
puts a.join(" ")
//  [ruby]
n, k = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)

k.times do
  arr = Array.new(n + 1) { 0 }

  a.each_with_index do |e, idx|
    l = [idx - e, 0].max
    r = [idx + e + 1, n].min
    arr[l] += 1
    arr[r] -= 1
  end

  tmp = 0
  arr.map! { |e| tmp += e }
  arr.pop
  a = arr

  if a.count(n) == n
    puts a.join(' ')
    exit
  end
end

puts a.join(' ')
//  [rust]
use std::cmp::*;
use std::collections::*;
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: usize = read();
    let k: usize = read();

    let mut a: Vec<usize> = (0..n).map(|_| read()).collect();
    for _i in 0..min(k, 2000) {
        let mut imos: Vec<i64> = vec![0; n];
        for i in 0..n {
            let left = max(0, i as i64 - a[i] as i64);
            let right = i + a[i] + 1;
            imos[left as usize] += 1;
            if right < n {
                imos[right as usize] -= 1;
            }
            //println!("{:?}",imos);
        }
        a[0] = imos[0] as usize;
        for j in 1..n {
            imos[j] += imos[j - 1];
            a[j] = imos[j] as usize;
        }
        //println!("{:?}",imos);
    }
    let f = n - 1;
    for i in 0..n {
        if i == f{
            println!("{}",a[i]);
        }else{
            print!("{} ",a[i]);
        }
    }
}
//  [python]
from itertools import izip_longest
import sys
O = raw_input()
E = raw_input()

for o, e in izip_longest(O, E):
    sys.stdout.write(o or "")
    sys.stdout.write(e or "")
print
//  [python]
O = input()
E = input()
E += '*' * (len(O) - len(E))
ans = ''
for i in range(len(O)):
    ans += O[i]
    ans += E[i]
if ans[-1] == '*':
    print(ans[:-1])
else:
    print(ans)
//  [python]
# -*- coding: utf-8 -*-                                                

import os
import sys
import math
import numpy as np

O = input()
E = input()
ans = ''
for i in range(len(E)):
    ans += O[i]
    ans += E[i]

if len(O) != len(E):
    ans += O[-1]

print(ans)
//  [python]
import numpy as np

O=list(input())
E=list(input())
lenOE=len(O)+len(E)

if lenOE%2==1: # もしOとEを足して奇数長なら、都合のためにダミーを最後に足す
    E+="."

print("".join(np.asarray([O,E]).T.reshape(-1,)[:lenOE]))
//  [python]
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy

def j(q):
    if q==1: print("YES")
    else:print("NO")
    exit(0)


def ct(x,y):
    if (x>y):print("GREATER")
    elif (x<y): print("LESS")
    else: print("EQUAL")

def ip():
    return int(input())


#n = ip()                              #入力整数1つ
#n,m= (int(i) for i in input().split())      #入力整数横2つ
#a,b,c = (int(i) for i in input().split())    #入力整数横3つ
#n,a,b,c= (int(i) for i in input().split())  #入力整数横4つ
#a = [int(i) for i in input().split()]        #入力整数配列
a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列
#n = ip()                      #入力セット(整数改行あり)(1/2)
#a=[ip() for i in range(n)]    #入力セット(整数改行あり)(2/2)
#a=[input() for i in range(h)]
#jの変数はしようできないので注意
#全足しにsum変数使用はsum関数使用できないので注意
b = input()
for i in range(len(a)):
    print(a[i],end='')
    if i == len(b):break
    print(b[i],end='')