Problem:
 Score : 300 points    Problem Statement There is a rectangle in a coordinate plane. The coordinates of the four vertices are (0,0) , (W,0) , (W,H) , and (0,H) .
You are given a point (x,y) which is within the rectangle or on its border. We will draw a straight line passing through (x,y) to cut the rectangle into two parts. Find the maximum possible area of the part whose area is not larger than that of the other. Additionally, determine if there are multiple ways to cut the rectangle and achieve that maximum.      Constraints  1 \leq W,H \leq 10^9  0\leq x\leq W  0\leq y\leq H  All values in input are integers.         Input Input is given from Standard Input in the following format:  W  H  x  y       Output Print the maximum possible area of the part whose area is not larger than that of the other, followed by 1 if there are multiple ways to cut the rectangle and achieve that maximum, and 0 otherwise.  The area printed will be judged correct when its absolute or relative error is at most 10^{-9} .        Sample Input 1 2 3 1 2      Sample Output 1 3.000000 0  The line x=1 gives the optimal cut, and no other line does.       Sample Input 2 2 2 1 1      Sample Output 2 2.000000 1

Solution (Python):

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

import random
import collections
import math
import itertools
import bisect

def real_main():
    w, h, x, y = read_int_array()
    area = w * h
    print(area / 2, (1 if x * 2 == w and y * 2 == h else 0) )



def solve():
    pass


def main():
    if False and 'PYCHARM_HOSTED' in os.environ:
        main_pycharm()
    else:
        real_main()


from copy import deepcopy
def main_pycharm():
    solution = solve

    test_inputs = None
    test_outputs = None
    judge = None
    slow_solution = None
    if solution is not None:
        if test_outputs is not None:
            test_with_answers(solution, test_inputs, test_outputs)
        if judge is not None:
            test_with_judge(solution, test_inputs, judge)
        if slow_solution is not None:
            test_with_slow_solution(solution, test_inputs, slow_solution)


def test_with_answers(solution, inputs_answers):
    total, wrong = 0, 0
    for args, test_ans in inputs_answers:
        ans = solution(*args.copy())
        if ans != test_ans:
            print('WRONG! ans=%s, test_ans=%s, args=%s' % (ans, test_ans, args))
            wrong += 1
        else:
            print('GOOD')
        total += 1
    print('ALL %d TESTS PASSED' % total if not wrong else '%d out of %d tests are WRONG' % (wrong, total))


def test_with_judge(solution, inputs_gen, judge):
    total, wrong = 0, 0
    for args in inputs_gen:
        ans = solution(*deepcopy(args))
        if not judge(deepcopy(ans), *deepcopy(args)):
            print('WRONG! ans=%s, args=%s' % (ans, args))
            wrong += 1
        total += 1
    print('ALL %d TESTS PASSED' % total if not wrong else '%d out of %d tests are WRONG' % (wrong, total))


def test_with_slow_solution(solution, inputs_gen, solution_slow):
    total, wrong = 0, 0
    for args in inputs_gen:
        ans = solution(*deepcopy(args))
        slow = solution_slow(*deepcopy(args))
        if ans != slow:
            print('WRONG! ans=%s, slow=%s, args=%s' % (ans, slow, args))
            wrong += 1
        total += 1
    print('ALL %d TESTS PASSED' % total if not wrong else '%d out of %d tests are WRONG' % (wrong, total))




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

def read():
    return input()

def read_int():
    return int(input())

def read_array(sep=None, maxsplit=-1):
    return input().split(sep, maxsplit)

def read_int_array():
    return [int(a) for a in read_array()]



if __name__ == "__main__":
    main()

Solution (Python):
W,H,x,y=map(int,input().split())

jug=0
if W/2==x:
    if H/2==y:
        jug=1

print(str(W*H/2)+" "+str(jug))

Solution (Python):
w, h, x, y = map(int, input().split())

if (w%2==0 and w//2==x and h%2==0 and h//2==y):
  print("%.11f" % (w*h/2), 1)
else:
  print("%.11f" % (w*h/2), 0)

Solution (Python):
W, H, x, y = map(int, input().split())

cp = ((W / 2), (H / 2))
np = (x, y)

print(W * H / 2, [0, 1][not(cp != np)])

Solution (Python):
W, H, x, y = map(int, input().split())
ans = W*H/2
if W/2==x and H/2==y:
    print(ans, 1)
else:
    print(ans, 0)

Solution (Python):
W,H,x,y=map(int,input().split())
if (x==W/2) and (y==H/2):
    print(W*H/2,1)
else:
    print(W*H/2,0)

Solution (Python):
W, H, x, y = map(int, input().split())
ans = W*H/2
if x == 0 or x == W or y == 0 or y == H:
    flg = 0
else:
    if x == W/2 and y == H/2:
        flg = 1
    else:
        flg = 0

print(ans, flg)

Solution (Python):


import math

W, H, x, y = (int(i) for i in input().split())
flag=0
if W/2 == x and H/2 == y:
    flag = 1
    pass

mense = W*H/2
print(mense, flag)

Solution (Python):

"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""

import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

class UnionFind(object):
    def __init__(self, n=1):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
    

"""
N, X = map(int, input().split())

x = list(map(int, input().split()))

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())


dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

add = 1 
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)


li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    


org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)




    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

"""



W, H, x, y = list(map(int, input().split()))
def main():
    A = (float(W)*float(H))/float(2)
    cnt = 0
    if W%2 == 0 and H%2==0 and x == W/2 and y == H/2:
        cnt = 1
    else:
        cnt = 0
    print(A, cnt)
                
                
                
            
            
                

    
if __name__ == '__main__':
    main()

Solution (Python):
W, H, x, y = map(int, input().split())

S = W * H / 2
if (x == W/2 and y == H/2):
    judge = 1
else:
    judge = 0
    
print(S, judge)

Solution (Python):
W,H,X,Y=input().split()
w=int(W)
h=int(H)
x=int(X)
y=int(Y)
S=w*h
T=S/2
print(T)
if x==w/2 and y==h/2:
  print(1)
else:
  print(0)

Solution (Python):
w, h, a, b = map(int, input().split())












ans = w * h / 2
ans2 = 0
if a == w / 2 and b == h / 2:
    ans2 = 1
print(ans, ans2)

Solution (Python):

from decimal import Decimal
W, H, x, y = map(int, raw_input().split())
d_W = Decimal(str(W) + ".0")
d_H = Decimal(str(H) + ".0")

menseki = d_W * d_H * Decimal("0.5")

val = 0
if x == W * 0.5 and y == H * 0.5:
  val = 1

print(str(menseki) + " " + str(val))

Solution (Python):
W,H,x,y = map(int,input().split())

area = W*H/2
if W % 2 == 0 and H % 2 == 0 and x == W//2 and y == H//2:
    print(area,1)
else:
    print(area,0)

Solution (Python):
import numpy as np

W, H, x, y = [int(v) for v in input().rstrip('\n').split()]

area = W * H

print(area / 2,end = " ")
print("1") if (x == W / 2) and (y == H / 2) else print("0")

Solution (Python):
w, h, x, y = list(map(int, input().split()))
area = w*h/2
ans2 = 0
if 2*x == w and 2*y == h:
    ans2 = 1
print(area, ans2)

Solution (Python):
W, H, x, y = list(map(int, input().split()))
if x == W/2 and y == H/2 :
    print(W*H/2, 1)
else :
    print(W*H/2, 0)

Solution (Python):
n, m, x, y = map(int, input().split())
print(n * m / 2, int(x == n / 2 and y == m / 2))

Solution (Python):
w, h, x, y = map(int, input().split())

s = w*h

if x == w/2 and y == h/2:
    print('%f 1' % (s/2))
else:
    print('%f 0' % (s/2))

Solution (Python):
W, H, x, y = map(int, input().split())

if W == H:
    if x == y and x == (W/2):
        print('{} 1'.format(0.5*W*H))
    else:
        print('{} 0'.format(0.5*W*H))
else:
    if x == (W/2) and y == (H/2):
        print('{} 1'.format(0.5*W*H))
    else:
        print('{} 0'.format(0.5*W*H))

Solution (Python):
inpl = lambda: list(map(int,input().split()))
W, H, x, y = inpl()
if W == x*2 and H == y*2:
    print(W*H/2, 1)
else:
    print(W*H/2, 0)

Solution (Python):
W,H,x,y = map(int,input().split())
print(W*H/2, 1 if x == W/2 and y == H/2 else 0)

Solution (Python):
W,H,x,y = map(int,input().split(' '))

S = W*H/2

f = False
if W % 2 == 0 and H % 2 == 0:
	if x == W//2 and y == H//2:
		f = True


print(S,int(f))

Solution (Python):
w, h, x, y = list(map(int, input().split()))

ans = w*h/2

a = 0
if x == w/2 and y == h/2:
  a = 1

print(ans, a)

Solution (Python):
W,H,x,y = (int(i) for i in input().split())
hoge = 0
if W / 2 == x and H / 2 == y and H > 0 and W > 0:
    hoge = 1

print(str(W*H/2) +" " + str(hoge))

Solution (Python):
W, H, x, y = map(int, input().split())
if x == W/2 and y == H/2:
    z = 1
else:
    z = 0
print(W*H/2, z)

Solution (Python):
W,H,x,y = map(int,input().split())

S = W*H/2
d = 0
if x==W/2 and y==H/2 :
    d=1
print("{} {}".format(S,d))

Solution (Python):
import sys, re




from copy import deepcopy,copy




def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

W, H, x, y = MAP()

if x == W / 2 and y == H / 2:
    print(W * H / 2, 1)
    
else:
    print(W * H / 2, 0)

Solution (Python):
w,h,x,y = map(int,input().split())

if x*2 == w and y*2 == h:
  print(str(w*h/2)+' '+str(1))
else:
  print(str(w*h/2)+' '+str(0))

Solution (Python):
W, H, x, y = map(int,input().split())


square = 1.0 * W * H / 2


patt = 0
if 1.0 * W / 2 == x and 1.0 * H / 2 == y:
    patt = 1

print(square, patt)

Solution (Python):

w,h,x,y=map(int,input().split())
num=0
if w/2==x and h/2==y:
    num=1
else:
    num=0
print("{} {}".format(w*h/2,num))

Solution (Python):







import sys
sys.setrecursionlimit(10**7)
from itertools import combinations, permutations 
from math import factorial
def combinations_count(n, r):
    
    
    
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n
    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]
    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot
    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])
    return result
def combination_with_repetition_count(n, r):
    return combinations_count(n + r - 1, r)
from collections import deque, Counter 
from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest 
from copy import deepcopy, copy 
from operator import itemgetter 
from functools import reduce
from fractions import gcd 
def gcds(numbers):
    return reduce(gcd, numbers)
def lcm(x, y):
    return (x * y) // gcd(x, y)
def lcms(numbers):
    return reduce(lcm, numbers, 1)



INF = 10 ** 18
MOD = 10 ** 6 + 3
modpow = lambda a, n, p = MOD: pow(a, n, p) 
def modinv(a, p = MOD):
    
    
    return modpow(a, p-2, p)
def modinv_list(n, p = MOD):
    if n <= 1:
        return [0,1][:n+1]
    else:
        inv_t = [0,1]
        for i in range(2, n+1):
            inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
        return inv_t
def modfactorial_list(n, p = MOD):
    if n == 0:
        return [1]
    else:
        l = [0] * (n+1)
        tmp = 1
        for i in range(1, n+1):
            tmp = tmp * i % p
            l[i] = tmp
        return l
def modcomb(n, k, fac_list = [], p = MOD):
    
    
    from math import factorial
    if n < 0 or k < 0 or n < k: return 0
    if n == 0 or k == 0: return 1
    if len(fac_list) <= n:
        a = factorial(n) % p
        b = factorial(k) % p
        c = factorial(n-k) % p
    else:
        a = fac_list[n]
        b = fac_list[k]
        c = fac_list[n-k]
    return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
def modadd(a, b, p = MOD):
    return (a + b) % MOD
def modsub(a, b, p = MOD):
    return (a - b) % p
def modmul(a, b, p = MOD):
    return ((a % p) * (b % p)) % p
def moddiv(a, b, p = MOD):
    return modmul(a, modpow(b, p-2, p))




    
    

    
    
    
    
    

    
    





r = lambda: sys.stdin.readline().strip() 
R = lambda: list(map(int, r().split())) 
Rmap = lambda: map(int, r().split())


W, H, x, y = R()
l = [0] * 2
l[0] = W * H / 2
if x == W / 2 and y == H / 2:
    l[1] = 1
else:
    l[1] = 0
print(*l)

Solution (Python):
W,H,x,y=map(int,input().split())
if W/2==x and H/2==y:
  print(W*H/2,1)
else:
  print(W*H/2,0)

Solution (Python):
W,H,X,Y = map(int,input().split())
print(W * H / 2, 0 if W / 2 != X or H / 2 != Y else 1)

Solution (Python):

w, h, x, y = map(int, input().split())

ans_surface = w * h / 2

ans_multiple = 0
if w / 2 == x and h / 2 == y:
    ans_multiple = 1

print(ans_surface, ans_multiple)

Solution (Python):
W, H, x, y = map(int, input().split())
if x == W/2 and y == H/2 and x != 0 and y != 0:
    print(W*H/2, 1)
else:
    print(W*H/2, 0)

Solution (Python):
W, H, x, y = map(int, input().split())

res_1 = W * H / 2
if x == W // 2 and y == H // 2 and W % 2 == 0 and H % 2 == 0:
    res_2 = 1
else:
    res_2 = 0

print(res_1, res_2)

Solution (Python):
w, h, x, y = map(int, input().split())

ans = w * h / 2

if x == w / 2 and y == h / 2:
    p = 1

else:
    p = 0

print(ans, p)

Solution (Python):
W, H, x, y = map(int, input().split())

print("{:.6f}".format(W * H / 2), end=" ")
print(1 if (x == W / 2 and y == H / 2) else 0)

Solution (Python):
whxy = list(map(int, list(input().split())))

w = whxy[0]
h = whxy[1]
x = whxy[2]
y = whxy[3]

s = w * h / 2

if x == w / 2 and y == h / 2:
    yesno = 1
else:
    yesno = 0

print(s, yesno)

Solution (Python):
W, H, x, y = map(int, input().split())
s = W * H
print(s / 2)
if x * 2 == W and y * 2 == H:
	print(1)
else:
	print(0)

Solution (Python):
def main():
    W, H, x, y = map(int, input().split())
    print('{} {}'.format(W * H * 0.5, '1' if x == W * 0.5 and y == H * 0.5 else '0'))
    return


if __name__ == '__main__':
    main()

Solution (Python):
list = input().split()
w = float(list[0])
h = float(list[1])
x = float(list[2])
y = float(list[3])
if w/2==x and h/2==y:
  i=1
else:
  i=0
print("%f %d" %(w*h/2, i))

Solution (Python):
W, H, x, y = map(int, input().split())

if x != W/2 or y != H/2:
    print(W*H/2, 0)
else:
    print(W*H/2, 1)

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
MOD = 1000000007
def POW(x, y): return pow(x, y, MOD)
def INV(x, m=MOD): return pow(x, m - 2, m)
def DIV(x, y, m=MOD): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())


W,H,x,y=LI()

if (x*2) == W and (y*2) == H:
    print(H*W*0.5, 1)
else:
    print(H*W*0.5, 0)

Solution (Python):
W, H, x, y = map(float, input().split())

print(H*W/2)

if x == W/2 and y == H/2:
    print(1)
else:
    print(0)

Solution (Python):
w,h,x,y=map(int,input().split())

area=w*h*0.5
if x==w/2 and y==h/2:
    plu=1
else:
    plu=0

print(area,plu)

Solution (Python):
W, H, x, y = map(int, input().split())
l = [0] * 4
if x*2 == W and y*2 == H:
    print(W*H*0.5, 1)
else:





    
    
    print(W*H*0.5 ,0)

Solution (Python):
line = input().split()
w = int(line[0])
h = int(line[1])
x = int(line[2])
y = int(line[3])

s = w * h /2

if w/2 == x and h/2 == y:
    another = 1
else:
    another = 0
    
print(str(s) + ' ' + str(another))

Solution (Python):
W,H,x,y=map(int,input().split())
if W%2==0 and x==W//2 and H%2==0 and y==H//2:
  ans=1
else:
  ans=0
print(W*H/2,ans)

Solution (Python):
W,H,x,y=map(int,input().split())
print(W*H/2,end=' ')
print(1 if W==2*x and H==2*y else 0)

Solution (Python):
W, H, x, y = map(int, input().split())

m2 = W * H * 0.5
ptn = 1 if W / 2 == x and H / 2 == y else 0

print(m2, ptn)

Solution (Python):
W, H, x, y = map(int,input().split())
if x == W/2 and y == H/2:
    print(float(W*H/2), 1)
else:
    print(float(W*H/2), 0)

Solution (Python):
W,H,x,y=map(int,input().split())
area = W*H/2
if x==W/2 and y==H/2:
    dou=1
else:
    dou=0

print(area,dou)

Solution (Python):
W, H, x, y = map(int,input().split())
t = 0
if W/2 == x and H/2 == y:
    t = 1
print((W*H)/2,t)

Solution (Python):
w, h, x, y = map(int, input().split(' '))

if w / 2 == x and h / 2 == y:
    c = '1'
else:
    c = '0'

print(w * h / 2, c)

Solution (Python):
import sys

W, H, x, y = list(map(int, sys.stdin.readline().strip().split(" ")))
b = 0

if x == W/2 and y == H/2:
    b = 1

print(str(W*H/2) + " " + str(b))

Solution (Python):
W, H, x, y = [int(i) for i in input().split()]

if (W / 2 - x ==0) & (H / 2 -y ==0):
    a = 1
else:
    a=0
print((W * H) /2, a)

Solution (Python):
W, H, x, y = map(int, input().split())
area = W*H
halfarea = area/2
if W == x*2 and H == y*2:
	cut = 1
else:
	cut = 0
print(halfarea, cut)

Solution (Python):
W,H,x,y = map(int,input().split())
if x*2 == W and y*2 == H:
  print(W*H/2,1)
else:
  print(W*H/2,0)

Solution (Python):
import numpy as np

def main():
    a=inputList()
    w,h,x,y=a[0],a[1],a[2],a[3]

    ans=w*h/2
    judge=0
    if(x*2==w and y*2==h):
        judge=1

    print(str(ans)+" "+str(judge))

def inputList():
    a=list(map(int,input().split()))
    return a

def multisort(li,index):
    return sorted(li,key=lambda x: x[index])

if(__name__=='__main__'):
    main()

Solution (Python):
W, H, x, y = list(map(int, input().split()))

area = (W * H) / 2
f = 0

if x == W / 2 and y == H / 2:
    f = 1

print("{0} {1}".format(area, f))

Solution (Python):
w,h,x,y=map(int,input().split())
print(w*h/2,[0,1][w==x*2 and h==y*2])

Solution (Python):
w, h, x, y = map(int, input().split())

s = w * h / 2
flag = 1 if x == w / 2 and y == h / 2 else 0

print(s, flag)

Solution (Python):
def main():
    n = [int(i) for i in input().split()]
    ans = 0
    if n[0]/2 == n[2] and n[1]/2 == n[3]:
        ans = 1
    print((n[0]*n[1])/2, ans)


if __name__ == "__main__":
    main()

Solution (Python):
w,h,x,y=map(int,input().split())
s=w*h/2
if w%2==0 and h%2==0 and x==w//2 and y==h//2:
    flag=1
else:
    flag=0
print(s,flag)

Solution (Python):
W, H, x, y = map(int, input().split())

print((H * W) / 2, end=" ")

if (W % 2 == 0 and W // 2 == x) and (H % 2 == 0 and H // 2 == y):
    print(1)
else:
    print(0)

Solution (Python):
def main():
    data = input().split()
    S = float(data[0]) * float(data[1]) / 2
    center = [float(data[0]) / 2, float(data[1]) / 2]
    plot = [float(data[2]), float(data[3])]
    if plot == center:
        print(S, 1)
    else:
        print(S, 0)

if __name__ == "__main__":
    main()

Solution (Python):
W, H, x, y = map(int, input().split())

x1, x2 = max(x, W - x), min(x, W - x)
y1, y2 = max(y, H - y), min(y, H - y)

S = W * H / 2
flag = (x1 == x2) and (y1 == y2)
v = 1 if flag else 0

print('{} {}'.format(S, v))

Solution (Python):
w,h,x,y = map(int,input().split())

a = w*h/2
b = 0

if 2*x ==w and 2*y==h:
    b = 1

print(a,b)

Solution (Python):
W, H, x, y = map(int,input().split())

print(W*H/2, end=" ")

if W/2 == x and H/2 == y:
    print(1)
else:
    print(0)

Solution (Python):
W, H, x, y = map(int, input().split())
S = W*H/2
print(S, int(W % 2 == 0 and H % 2 == 0 and W//2 == x and H//2 == y))

Solution (Python):
w,h,x,y = map(int,input().split())
a = 0
if x ==w/2 and y == h/2:
  a = 1
print(w*h/2,a)

Solution (Python):
class Solution:
    def main(self):
        W, H, x, y = map(int, input().split())
        print(W*H/2, int(x == W/2 and y == H/2))

if __name__ == '__main__':
    Solution().main()

Solution (Python):
W,H,x,y=map(int,input().split())
a=(W*H)/2
b=int(W/2==float(x) and H/2==float(y))
print(a,b)

Solution (Python):
w,h,x,y = map(int, input().split())
a = (w * h) / 2
b = 0
if w % 2 == 0 and h % 2 == 0:
    if w // 2 == x and h // 2 == y:
        b = 1
print(a,b)

Solution (Python):
w,h,x,y=map(int,input().split())
if x==(w/2) and y==(h/2):
    print(w*h/2,1)
else:
    print(w*h/2,0)

Solution (Python):
h,w,x,y = map(int,input().split())
print(h*w/2,end=" ")
if h%2 != 0 or w%2 != 0:
  print(0)
else:
  if int(h/2) == x and int(w/2) == y:
    print(1)
  else:
    print(0)

Solution (Python):

w, h, x, y = list(map(int, input().rstrip().split()))
area = w * h * 0.5
if (x, y) == (w * 0.5, h * 0.5):
    print(area, 1)
else:
    print(area, 0)

Solution (Python):

w,h,x,y = [int(i) for i in input().split()]
print(w*h/2,end = "")
if w == 2*x and h ==2*y:
    print(" 1")
else:
    print(" 0")

Solution (Python):
W,H,x,y = map(int, input().strip().split(' '))
print('{} {}'.format(W*H/2 ,int(x*2==W and y*2==H)))

Solution (Python):
W, H, x, y = map(int, input().split())
if x == W /2 and y == H / 2:
    print(W * H /  2, 1)
else:
    print(W * H / 2, 0)

Solution (Python):
W, H, x, y = list(map(int, input().split()))

anscnt = 0
if x == W / 2 and y == H / 2:
    anscnt = 1

print(W*H/2, anscnt)

Solution (Python):
W, H, x, y = map(float, input().split())

if x == W / 2 and y == H / 2:
    multi = 1
else:
    multi = 0
    
print("{} {}".format(W * H / 2, multi))

Solution (Python):
w, h, x, y = map(int, input().split())

if (w / 2 == x) and (h / 2 == y):
    chk = 1
else:
    chk = 0

print((w * h)/2, chk)

Solution (Python):
W,H,x,y=map(int,input().split())
a = W*H/2
if W==2*x and H==2*y:
    b=1
else:
    b=0
print(a,b)

Solution (Python):
W, H, x, y = map(int, input().split())
print(W * H / 2, 1 if x != 0 and y != 0 and W / x == 2 and H / y == 2 else 0)

Solution (Python):
W, H, x, y = map(int, input().split())

area = (W * H) / 2

center = (W/2, H/2)
print(area, 1 if center == (x, y) else 0)

Solution (Python):
W, H, x, y = map(int, input().split())

area = W * H / 2
print(W * H / 2, 1 if x == W / 2 and y == H / 2 else 0)

Solution (Python):
W, H, x, y = map(int, input().split())

s = W * H / 2

dif = 0
if W == 2 * x and H == 2 * y:
    dif = 1

print("{} {}".format(s, dif))

Solution (Python):
from sys import stdin
import numpy as np










W, H, x, y = [int(x) for x in stdin.readline().rstrip().split()]
S = W*H/2
frag = 0
if W==2*x and H==2*y:
  frag=1

print(S,frag)

Solution (Python):
w,h,x,y = map(int,input().split())
flag = 0
ans = float(w)*float(h)/2.000000

if w/2 == float(x) and h/2 == float(y):
  flag = 1
print(ans,flag)

Solution (Python):
W,H,x,y= map(int,input().split())

ans_s = W*H/2
ans_b = 0

if W%2 == 0 and x==W//2 and H%2 == 0 and y ==H//2:
    ans_b = 1

print(ans_s,ans_b)

Solution (Python):
W,H,x,y = map(int, input().split())			

s= float(W/2*H)

a=0
if W/2==x and H/2==y: a=1

print(s,a)

Solution (Python):
w,h,x,y=map(int,input().split())
print(h*w/2,end=' ')
if x==w/2 and y==h/2:
    print('1')
else:
    print('0')

Solution (Python):
w, h, x, y = map(int, input().split())

if w == x * 2 and h == y * 2:
    print(w * h / 2, 1)
else:
    print(w * h / 2, 0)

Solution (Python):
w,h,x,y = map(int, input().split())
print(w*h/2, 1*(x==w/2 and y==h/2))

Solution (Python):
W,H,x,y = map(int, input().split())

ans = W * H / 2

ans_s = 0

if(x == W/2 and y == H /2):
	ans_s = 1

print(ans,ans_s)

Solution (Python):
W, H, x, y = map(int, input().split())
result1 = float( W * H / 2 )

result2 = 0
if ( W % 2 == 0 and H % 2 == 0) and ( int(W / 2) == x and int(H / 2) == y):
    result2 = 1

print(result1, result2)

Solution (Python):
l = input()
w, h, x, y = map(int, l.split())

f = 1 if x * 2 == w and y * 2 == h else 0

area = w * h / 2

print(area, f)

Solution (Python):
W, H, x, y = map(int, input().split())
area = W * H / 2
if x == W / 2 and y == H / 2:
  ptn = 1
else:
  ptn = 0
print(area, ptn)

Solution (Python):
W, H, x, y = map(int, input().split())

menseki = W * H / 2
if x == W / 2 and y == H / 2:
    houhou = 1
else:
    houhou = 0

print(menseki, houhou)

Solution (Python):
W, H, x, y = map(int, raw_input().split())
mul = 0
if x*2 == W and y*2 == H:
    mul = 1
A = W * H / 2.0
print '%f %d' % (A, mul)

Solution (Python):
W, H, x, y = map(int, input().split())

area = W * H
center = x * 2 == W and y * 2 == H

print('{} {}'.format(area / 2, 1 if center else 0))

Solution (Python):
W, H, x, y = map(int, input().split())
bool_str = '1' if (x, y) == (W-x, H-y) else '0'
print(W*H/2, bool_str)

Solution (Python):
W, H, x, y = map(int, input().split())

S = W*H/2

if 2*x == W and 2*y == H:
    print(S, 1)
else:
    print(S, 0)

Solution (Python):
w, h, x, y = map(int, input().split())

print(w * h / 2, end = " ")

if 2 * x == w and 2 * y == h:
    print("1")

else:
    print("0")

Solution (Python):
W, H, x, y = list(map(int, input().split()))
is_center = 1 if x*2 == W and y*2 == H else 0
print(W*H/2, is_center)

Solution (Python):
W,H,x,y = map(int, input().split())

ans2 = 0
if ((W / 2) == x):
  if ((H / 2) == y):
    ans2 = 1

ans1 = (W * H / 2)

print(ans1, ans2)

Solution (Python):
W,H,x,y  = map(int, input().split())
print(W*H/2)
if x==W/2 and y==H/2:
    print(1)
else:
    print(0)

Solution (Python):
W, H, x, y = list(map(int, input().split()))

f = 0
if x == W/2 and y == H/2:
    f = 1

print(str(W * H / 2) + " " + str(f))

Solution (Python):
W,H,x,y = map(int,input().split())
men = W*H/2
if x == W/2 and y == H/2:
    a = 1
else:
    a = 0
print(' '.join(map(str,[men,a])))

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

def main(): 
    W, H, x, y = LI()
    if x == W/2 and y == H/2: 
        multiple_answers = 1
    else:
        multiple_answers = 0
    ans = W * H / 2

    print(ans, multiple_answers)

main()

Solution (Python):
W,H,x,y=map(float,input().split())
answer=0
if W/2==x and H/2==y:
  answer=1
print(W*H/2,answer)

Solution (Python):
W, H, x, y =  map(int, input().split())
print(W*H/2)
if x == W/2 and y == H/2:
	print(1)
else:
	print(0)

Solution (Python):



def main():
    W, H, x, y = map(int, input().split())

    print('{:.9f}'.format(W*H/2), 1 if W==x*2 and H==y*2 else 0)



if __name__ == '__main__':
    main()

Solution (Python):
W, H, x, y = map(int, input().split())


if (W / 2 == x and H / 2 == y):
    print(W * H / 2, 1)
else:
    print(W * H / 2, 0)

Solution (Python):
W, H, x, y = map(int, input().split())

print(W*H/2, end=" ")
if x==W/2 and y==H/2:
	print(1)
else:
	print(0)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def main():
    W, H, x, y = LI()
    if x == W/2 and y == H/2:
        c = 1
    else:
        c = 0
    print(W*H/2, c)


if __name__ == "__main__":
    main()