#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define pii pair <int, int>
#define sz(a) (int)(a.size()) 
#define resize(v) v.resize(unique(all(v)) - v.begin()); 
#define all(a) a.begin(), a.end()
#define forit(it, s) for(__typeof(s.begin()) it = s.begin(); it != s.end(); it ++)
#define ld long double

using namespace std;

void Fast_Read_Out()
{
	ios_base::sync_with_stdio(0);
	cin.tie(), cout.tie();
}

void Random()
{
	unsigned int seed;
	asm("rdtsc" : "=A" (seed));
	srand(seed);        
}

unsigned int Time()
{
	 unsigned int time = clock() / 1000.00;
	 return time;
}

const int inf = int(1e9) + 123;
const ld pi = acos(-1.0);
const ld eps = 1e-6;

ld Lambda;

ld Sqr(ld ans)
{
	return ans * ans;
}

ld Add(ld a, ld b)
{
	return a + b;
}

struct Point
{
	ld x, y;

	void Read()
	{
		cin >> x >> y;
	}

	Point()
	{
	}

	Point(ld _x, ld _y)
	{
		x = _x;
		y = _y;
	}

	ld Distance(Point A)
	{
		return sqrt(Add(Sqr(A.x - x), Sqr(A.y - y)));
	}

	ld Polar_Angle()
	{
		ld alpha = atan2(y, x);
		if(alpha < 0) alpha += 2 * pi;
		return alpha;
	}

	Point Find_Bisector(Point A)
	{
		ld Bx = (x + Lambda * A.x) / (1 + Lambda);
		ld By = (y + Lambda * A.y) / (1 + Lambda);
		Point K;
		K.x = Bx;
		K.y = By;
		return K;
	}

	ld Heron(Point A, Point B)
	{
		ld a = Distance(A);
		ld b = Distance(B);
		ld c = A.Distance(B);
		ld s = (a + b + c) / 2;
		return (sqrt(s * (s - a) * (s - b) * (s - c)));
	}
};

struct Line
{
	ld a, b, c;

	void Read()
	{
		cin >> a >> b >> c;
	}

	Line()
	{
	}

	Line(ld _a, ld _b, ld _c)
	{
		a = _a;
		b = _b;
		c = _c;
	}

	void Show()
	{
		cout << setprecision(10) << fixed << a << ' ' << b << ' ' << c << endl;
	}

	ld Distance_Point_Line(Point M)
	{
		ld ans = abs(a * M.x + b * M.y + c);
		ld res = sqrt(a * a + b * b);
		return ans / res;
	}

	void Make_Perpendicular(Point M, Line L)
	{
		a = L.b;
		b = -L.a;
		c = -L.b * M.x + L.a * M.y;
	}

	Point Intersection_Point(Line L2)
	{
		ld k = L2.b * a - b * L2.a;
		ld res = c * L2.a - L2.c * a;
		ld y = res / k;
		res = L2.c * b - c * L2.b;
		k = a * L2.b - L2.a * b;
		ld x = res / k;
		return Point(x, y);
	}

	void Make_Line(Point A, Point B)
	{
		a = B.y - A.y;
		b = (B.x - A.x) * -1;
		c = A.y * (B.x - A.x) + (B.y - A.y) * A.x * -1;
	}

	int On_Line(Point k)
	{
		if(k.x * a + k.y * b + c > 0) return 1;
		else if(k.x * a + k.y * b + c == 0) return 0;
		else return -1;
	}
};

struct Vector
{
	ld x, y;

	void Make_Vector(Point A, Point B)
	{
		x = B.x - A.x;
		y = B.y - A.y;
	}

	Vector()
	{
		
	}

	Vector(ld _x, ld _y)
	{
		x = _x;
		y = _y;
	}

	ld Scalar_Product(Vector B)
	{
		ld curx = B.x * x;
		ld cury = B.y * y;
		return curx + cury;
	}

	ld Size()
	{
		ld xx = x * x;
		ld yy = y * y;
		ld xy = xx + yy;
		return sqrt(xy);
	}

	ld Pseudo_Scalar_Product(Vector B, ld A)
	{
		ld ans = Size() * B.Size() * sin(A);
		return ans;
	}
};

bool cmp(const Point &a, const Point &b)
{
	if(a.x == b.x) return a.y < b.y;
	else return a.x < b.x;
}

bool Is_Down(Point a, Point b, Point c)
{
	return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y) < 0;
}

bool Is_Up(Point a, Point b, Point c)
{
	return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y) > 0;
}

vector <Point> down, up, f, s;

vector <Point> Convex_Hull(vector <Point> a)
{
	if(a.empty()) return a; 
	sort(a.begin(), a.end(), &cmp);
	Point p1 = a[0], p2 = a.back();
	down.clear();
	up.clear();
	up.pb(p1);
	down.pb(p1);
	for(int i = 1; i < sz(a); i++)
	{
		if(i == sz(a) - 1 || Is_Down(p1, a[i], p2))
		{
			while(sz(up) >= 2 && !Is_Down(up[sz(up) - 2], up[sz(up) - 1], a[i])) up.pop_back();
			up.pb(a[i]);
		}

		if(i == sz(a) - 1 || Is_Up(p1, a[i], p2))
		{
			while(sz(down) >= 2 && !Is_Up(down[sz(down) - 2], down[sz(down) - 1], a[i])) down.pop_back();
			down.pb(a[i]);
		}	
	}
	a.clear();
	for (int i = 0; i < sz(up); i++) a.pb(up[i]);
	for (int i = sz(down) - 2; i > 0; i--) a.pb(down[i]);
	return a;
}

ld Area(vector <Point> a)
{
	ld Ans = 0;
	int n = sz(a);
	for(int i = 0; i < n; i++) Ans += (a[(i + 1) % n].x - a[i].x) * (a[(i + 1) % n].y + a[i].y) / 2.0;
	return fabs(Ans);		
}

bool Equal(ld a, ld b)
{
	return fabs(a - b) < eps;
}

multiset <ld> S;
multiset <ld> what;
Point a[5];
Point O1, O2;
Line L;
Point O;
Line d;

int main ()
{
	#ifdef JUDGE
		freopen("input.txt", "r", stdin);
	#endif 
	Random();
	Fast_Read_Out();
	a[3].Read();
	O1.Read();
	bool ok = 0;
	if(O1.y + O1.y == a[3].y && O1.x + O1.x == a[3].x) ok = 1;
	cout << fixed << setprecision(6) << a[3].x * a[3].y / 2 << ' ' << ok << endl; 
	#ifdef JUDGE                                                                                                               
//		cout << Time() << endl;
	#endif
}
// Easy Peasy Lemon Squeezy

Measured memory_bytes: 256