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):
W, H, x, y = map(int, input().split())
ans = W*H/2

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

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())


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

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())
if x*2==w and y*2==h:
  print(str(w*h/2) + " 1")
else:
  print(str(w*h/2) + " 0")

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

Solution (Python):
w,h,x,y = map(int, input().split())
if w % 2 == 0 and h % 2 == 0 and 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 == w/2 and y == h/2:
  print(str(w*h/2)+' '+'1')
else:
  print(str(w*h/2)+' '+'0')

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

print(S, ans)

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

ans = w*h/2
ans2 = 0

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

print(ans,ans2)

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

Solution (Python):
import numpy as np
W, H, x, y = map(int, input().split())
min_max = W * H / 2
if x == (W / 2) and y == (H / 2):
  multi_point = 1
else:
  multi_point = 0
print("{} {}".format(min_max, multi_point))

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

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

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

S = W * H / 2
multi = int(x * 2 == W and y * 2 == H)
print("{} {}".format(S, multi))

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

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())

SQR = W*H

H_SQR = SQR/2

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

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())
print((w*h)/2, 1 if w/2==x and h/2==y else 0)

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

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

x0, y0 = W / 2, H / 2
ans = W * H / 2

if (x0, y0) == (x, y):
    print(ans, 1)
else:
    print(ans, 0)

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

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

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

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

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

Solution (Python):
w,h,x,y =map(int, input().split())
men=w*h
bun1=x*h
bun2=(w-x)*h
bun3=w*y
bun4=w*(h-y)
if w/2==x and h/2==y:
    ans=1
else:
    ans=0
print(w*h/2, ans)

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

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

min_max = W * H / 2
if W/2 == x and H/2 == y:
    multi_pattern = 1
else:
    multi_pattern = 0

print(min_max, multi_pattern)

Solution (Python):

import sys


def solve(W: int, H: int, x: int, y: int):
    r1 = W*H /2
    if W*y == H*x and W*y == -H*x+H*W:
        r2 = 1
    else:
        r2 = 0
    print(r1, r2)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    W = int(next(tokens))  
    H = int(next(tokens))  
    x = int(next(tokens))  
    y = int(next(tokens))  
    solve(W, H, x, y)

if __name__ == '__main__':
    main()

Solution (Python):
ll= lambda : list(map(int,input().split()))
testcases=1

for testcase in range(testcases):
	[w,h,x,y]=ll()
	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 2*x==w and 2*y==h:
  print(w*h/2,1)
else:
  print(w*h/2,0)

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

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())
S = float(W)*float(H)/2.0
if W/2 == x and H/2 == y:
	k = 1
else:
	k = 0
print(str(S) + " " + str(k))

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

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

Solution (Python):


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

area = w * h / 2.0
if x == w / 2.0 and y == h / 2.0:
	print("{} {}".format(area, 1))
else:
	print("{} {}".format(area, 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())
print(w*h/2.0,end=' ')
if 2*x==w and 2*y==h:
    print(1)
else:
    print(0)

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

s = 0.5 * w * h
has_multi = 0

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

print(s, has_multi)

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

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

Solution (Python):

import re
import bisect
from datetime import datetime as dt
import bisect
import math

def gcd(a, b):
    return math.gcd(a, b)

def lcm(a, b):
    return a * b / gcd(a, b)

class slist(list):
    def __init__(self, *args, **kw):
        list.__init__(self, *args, **kw)
        self.sort()

    def append(self, value):
        bisect.insort(self,value)

    def index_left(self, value):
        return bisect.bisect_left(self, value)


if __name__ == '__main__':
    W, H, x, y = map(float, input().split())
    if x == W / 2.0 and y == H / 2.0:
        print('{0} {1}'.format(W * H / 2.0, 1))
    else:
        print('{0} {1}'.format(W * H / 2.0, 0))

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

Solution (Python):

W,H,x,y = map(int,input().split())
f = 1 if abs(H/2 - y) < 1e-9 and abs(W/2 - x) < 1e-9 else 0
print((H*W/2), f)

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline


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

D=[0]

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 w%2==0 and h%2==0 and x==w//2 and y==h//2:print(w*h/2,1)
else:print(w*h/2,0)

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

Solution (Python):
import sys,heapq
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
def ddprint(x):
  if DBG:
    print(x)

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

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

area = W * H

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

Solution (Python):

import sys


def solve(W: int, H: int, x: int, y: int):
    result1 = W*H * 0.5
    if W*y == H*x and W*y == -H*x+H*W:
        result2 = 1
    else:
        result2 = 0
    print(result1, result2)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    W = int(next(tokens))  
    H = int(next(tokens))  
    x = int(next(tokens))  
    y = int(next(tokens))  
    solve(W, H, x, y)

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import sys

readline = sys.stdin.readline

W, H, x, y = map(int, readline().split())

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

Solution (Python):
def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A

W, H, x, y = InputToInt()

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

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

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

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

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

print(*calc())

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

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

print(str(W*H/2) + t)

Solution (Python):
def solve(w, h, x, y):
    area = w * h / 2.0
    if 2 * x == w and 2 * y == h:
        multi = 1
    else:
        multi = 0
    return area, multi


def main():
    w, h, x, y = (int(z) for z in input().split())
    area, judge = solve(w, h, x, y)
    print("{:.12f} {}".format(area, judge))


if __name__ == "__main__":
    main()

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

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

Solution (Python):
w,h,x,y = map(float,input().split())
mx,my = w/2,h/2
res= []
res.append(w*h/2)
if x==mx and y==my:
    res.append(1)
else:
    res.append(0)
print(res[0],res[1])

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

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

Solution (Python):
import sys
from collections import Counter, deque, defaultdict





sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7







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

area = H * W / 2

num = 0

e = 0.000001
if abs(x - W / 2) < e and abs(y - H / 2) < e:
    num = 1

print("{} {}".format(area, num))

Solution (Python):
w, h, x, y = [int(x) for x in input().split()]
if (x == w / 2 and y == h / 2):
  print(str(w * h / 2) + ' 1')
else:
  print(str(w * h / 2) + ' 0')

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

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

chuuw, chuuh = W/2, H/2

chuuten = 0

if x == chuuw and y == chuuh:
    chuuten = 1

menseki = W * H / 2

print("{:.10f} {}".format(menseki, chuuten))

Solution (Python):

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


if (W == x*2)and(H == y*2):
    result = '1'
else:
    result = '0'
print(format(W*H/2,'f')+' '+result)

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

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

Solution (Python):
def inpl():
    return list(map(int, input().split()))


W, H, x, y = inpl()

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

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

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

Solution (Python):
import sys, itertools, collections
sys.setrecursionlimit(10**7)
def lmi(): return list(map(int, input().split()))

w, h, x, y = lmi()

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

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

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

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())

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

print(area, multi)

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


half = W * H / 2
print(half)

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

Solution (Python):



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



'''
for i in range h:
    temp = list(map(int, input().split()))
    table.append(temp)
'''
maxS = w*h/2
a = 0
if (w == 2*x) and (h == 2*y):
    a = 1
print('{:f} {}'.format(maxS, a))

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



debug = False

def dprint(*objects):
    if debug == True:
        print(*objects)

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

    area = w * h
    half = area / 2.0

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

    print(half, flag)

solve()

Solution (Python):
import sys
input=sys.stdin.readline
from collections import deque
from heapq import heappush,heappop
import re

def int_raw():
    return int(input())
 
def ss_raw():
    return input().split()
 
def ints_raw():
    return tuple(map(int, ss_raw()))


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


DIV = 10**9+7

def ncr(n, r, mod=DIV):
	r = min(r, n-r)
	ret = 1
	for i in range(1, r+1):
		ret = ret * (n-i+1) % mod
		ret = ret * mod_inv(i, mod) % mod
	return ret


def main():
    ans =0
    W,H,x,y = ints_raw()
    ans =W*H/2
    
    w2 = W/2
    h2 = H/2
    is_one = 1
    if w2 ==x and h2 ==y:
        is_one =1
    
    else:
        is_one =0
    print(ans,is_one)
main()

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

w,h,x,y = na()
a = 1 if w/2 == x and h/2 == y else 0

print(w*h/2,a)

Solution (Python):
from decimal import *

W,H,x,y=map(int, input().split())
flag = '0'
if x==W/2 and y==H/2:
  flag = '1'
print(Decimal(W*H/2),flag)

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):
import sys

fin = sys.stdin.readline
W, H, x, y = [int(elem) for elem in fin().split()]

center_x = W / 2
center_y = H / 2

if x == center_x and y == center_y:
    multi_hantei = 1
else:
    multi_hantei = 0

print((W*H)/2, multi_hantei)

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

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

print(W*H/2, ans)

Solution (Python):
import sys
input = sys.stdin.readline
ri = lambda: int(input())


rl = lambda: map(int,input().split())
rr = lambda N: [list(l) for l in zip(*[rl() for _ in range(N)])]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18
MOD = 10**9+7

W,H,x,y=rl()
men = W*H/2
dif = 10**(-9)
ans = 0
if W/2-dif <= x and x <= W/2+dif and H/2-dif <= y and y <= H/2+dif:
    ans = 1 

print('{:.6f} {}'.format(men,ans))

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 input()

def main():
    W, H, x, y = LI()
    s = W * H * 0.5
    d = 1 if (x == W / 2.0 and y == H / 2.0) else 0
    print(s, d)
    return

main()

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):


def solve():
    W,H,x,y = map(int, input().split())
    res = '{} {}'.format(W*H/2 ,int((W/2,H/2) == (x,y)))
    return res

if __name__ == '__main__':
    print(solve())

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:
  a = 1
else:
  a = 0
print(h*w/2,a)

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 = map(int, input().split())
ret = (W*H)/2
judge = 0
if W / 2 == x and H / 2 == y:
    judge = 1
print(ret, judge)

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

Solution (Python):
W,H,x,y  = [int(i) for i in input().split()]
if W/2 == x and H/2 == y:
    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())
mass = w * h / 2
if x == w/2 and y == h / 2:
    div = 1
else:
    div = 0
print(str(mass) + " " + str(div))

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):

"""
Created on Sun Jun 16 20:56:35 2019

@author: Yamazaki Kenichi
"""

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

print(W*H/2)

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

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

Solution (Python):
W, H, x, y = list(map(int, input().split()))
mul = 0
if W / 2 == x and H / 2 == y:
    mul = 1
print('{:.9f} {}'.format(W*H/2.0, mul))

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

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


ans.append(str(W * H / 2))


if x * 2 == W and y * 2 == H:
    ans.append('1')
else:
    ans.append('0')

print(' '.join(ans))

Solution (Python):

import sys


def solve(W: int, H: int, x: int, y: int):
    ret = W * H / 2
    tmp = 0
    if x * 2 == W and y * 2 == H:
        tmp = 1
    print(ret)
    print(tmp)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    W = int(next(tokens))  
    H = int(next(tokens))  
    x = int(next(tokens))  
    y = int(next(tokens))  
    solve(W, H, x, y)

if __name__ == '__main__':
    main()

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

Solution (Python):
W,H,x,y = [int(x) for x in input().split()]
s = W*H/2
means = 0
if(x==W/2 and y==H/2):
    means = 1
print(s,means)

Solution (Python):
w, h, x, y = map(int, input().split())
print(w * h / 2.0, 1 if x * 2 == w and y * 2 == h else 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):
w,h,x,y = map(int,input().split())
a = w*h/2
if w%2 == 0 and h%2 == 0:
    if x == int(w/2) and y == int(h/2):
        print(a, 1)
    else:
        print(a, 0)
else:
    print(a, 0)

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

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

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

big = w*h/2
second = 0
if w/2==x and h/2==y:
    second = 1

print(big,second)

Solution (Python):
import math


w, h, x, y = [int(i) for i in input().split()]







kotae = w * h / 2

flag = 0

if ( (w / 2 == x) and (h / 2 == y) ) :
    flag = 1


print(kotae, flag)

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):
w, h, x, y = [int(i) for i in input().split()]

area_max = w * h / 2

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

print('{} {}'.format(area_max, way_num))

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())

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 = [int(c) for c in input().split()]
n = 1 if x*2==W and y*2==H else 0
print(W*H/2, n)

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

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

W,H,x,y=MAP()

ans1=W*H/2
if x==W/2 and y==H/2:
    ans2=1
else:
    ans2=0

print(ans1, ans2)

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

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


m()

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

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

area = w * h / 2
flag = 2 * x == w and 2 * y == h
print("{} {}".format(area, int(flag)))

Solution (Python):
inp = input()
split_input = inp.split()
w = int(split_input[0])
h = int(split_input[1])
x = int(split_input[2])
y = int(split_input[3])
small_area = w * h / 2
if x*2 == w and y*2 == h:
    print(str(small_area) + " " + str(1))
else:
    print(str(small_area) + " " + str(0))

Solution (Python):

"""
AtCoder A
"""

import sys, math, random
import numpy as np







 
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
 
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
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 I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()


def main():
    W, H, x, y = list(map(int,input().split()))
    if W==x*2 and H==y*2:
        print("%f 1"%(W*H/2))
    else:
        print("%f 0"%(W*H/2))
    
if __name__ == "__main__":
    main()

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())
if x==w/2 and y==h/2:
    print(w*h/2,1)
else:
    print(w*h/2,0)

Solution (Python):


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

    S = W*H/2

    m = 1 if W%2==0 and H%2==0 and W//2==x and H//2==y else 0

    print(S, m)


if __name__ == '__main__':
    main()

Solution (Python):
W, H, x, y = [int(x) for x in input().split()]
half = W * H / 2
print(half, int((x, y)==(W/2, H/2)))

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

if W == 0 or H == 0:
  print(0, 1)
  exit()

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())
ans = w*h/2
if x == w/2 and y == h/2:
    print(ans, 1)
else:
    print(ans, 0)

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def s(generator, splitter, mapper):
    return [ mapper(s) for s in generator().split(splitter) ]


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

w,h,x,y = get_nums_l()

s = (w*h) / 2
t = 1 if (x == w/2) and (y == h/2) else 0

print(s, t)

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

s = w * h / 2
if w / 2 == x and h / 2 == y:
    center = True
else:
    center = False

print(str(s) + " " + str(int(center)))

Solution (Python):
from bisect import bisect_left, bisect_right; from collections import Counter, defaultdict, deque, OrderedDict; from copy import deepcopy; from fractions import gcd; from functools import lru_cache, reduce; from math import ceil, floor; from sys import stdin, setrecursionlimit
import heapq as hq; import itertools as its; import operator as op



inf = float('inf')
input = stdin.readline


def main():
    w, h, x, y = get_li()
    area = w * h / 2
    multiple = 1 if w // 2 == x and w % 2 == 0 and h // 2 == y and h % 2 == 0 else 0
    print(area, multiple)
    return


def get_int():
    return int(input())


def get_float():
    return float(input())


def get_str():
    return input().strip()


def get_li():
    return [int(i) for i in input().split()]


def get_lf():
    return [float(f) for f in input().split()]


def get_lc():
    return list(input().strip())


def get_data(n, types, sep=None):
    if len(types) == 1:
        return [types[0](input().strip()) for _ in range(n)]
    return list(zip(*(
        [t(x) for t, x in zip(types, input().strip().split(sep=sep))]
        for _ in range(n)
    )))


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

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

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

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(float,input().split())
print((W*H)/2,(0,1)[x==W/2 and y==H/2])

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

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

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

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


def solve(W, H, x, y):
    half = W * H / 2.0
    is_multiple = 1 if (x * 2 == W and y * 2 == H) else 0
    return half, is_multiple


if __name__ == '__main__':
    inputs = read()
    print("%.10f %d" % solve(*inputs))

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

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

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

ansA = W * H / 2

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

print(ansA, ansB)

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

ans1=w*h/2

ans2=0

if w/2==x and h/2==y:
    ans2=1
print('{0} {1}'.format(ans1, ans2))

Solution (Python):

import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    w,h,x,y = f()

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

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


solve()

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

Solution (Python):


def gcd_core(a, b):
    if b == 0:
        return a
    else:
        return gcd_core(b, a % b)


def gcd(arr):
    g = gcd_core(arr[0], arr[1])
    for i in range(2, len(arr)):
        g = gcd_core(g, arr[i])
    return g

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

mm = w*h/2
mul = 0

if abs(w/2-x) < 0.001 and abs(h/2-y) < 0.001:
    mul = 1
else:
    mul = 0

print(mm,mul)

Solution (Python):
import bisect
import os
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import string
import sys

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

sys.setrecursionlimit(2147483647)
INF = float("inf")

W, H, X, Y = list(map(int, sys.stdin.readline().split()))

center = X * 2 == W and Y * 2 == H
print(W * H / 2, int(center))

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

menseki = w * h
bunkatu = x == w/2 and y == h/2

print(menseki / 2,1 if bunkatu else 0)

Solution (Python):




W,H,x,y = map(int, input().split())
s,pat = [float(W*H/2),0]
if x*2==W and y*2==H:
  pat = 1

print(s,pat)