Long time ago Alex created an interesting problem about parallelogram. The input data for this problem contained four integer points on the Cartesian plane, that defined the set of vertices of some non-degenerate (positive area) parallelogram. Points not necessary were given in the order of clockwise or counterclockwise traversal.

Alex had very nice test for this problem, but is somehow happened that the last line of the input was lost and now he has only three out of four points of the original parallelogram. He remembers that test was so good that he asks you to restore it given only these three points.


-----Input-----

The input consists of three lines, each containing a pair of integer coordinates x_{i} and y_{i} ( - 1000 ≤ x_{i}, y_{i} ≤ 1000). It's guaranteed that these three points do not lie on the same line and no two of them coincide.


-----Output-----

First print integer k — the number of ways to add one new integer point such that the obtained set defines some parallelogram of positive area. There is no requirement for the points to be arranged in any special order (like traversal), they just define the set of vertices.

Then print k lines, each containing a pair of integer — possible coordinates of the fourth point.


-----Example-----
Input
0 0
1 0
0 1

Output
3
1 -1
-1 1
1 1



-----Note-----

If you need clarification of what parallelogram is, please check Wikipedia page:

https://en.wikipedia.org/wiki/Parallelogram

Difficulty: EASY
Tags: Geometry

Complete search

Constructive algorithms
Skill types: Complete search

Starter code:

Solutions:
(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
ans = set()
ans.add((x3 + (x1 - x2), y3 + (y1 - y2)))
ans.add((x3 - (x1 - x2), y3 - (y1 - y2)))
ans.add((x1 - (x3 - x2), y1 - (y3 - y2)))
ans.add((x1 + (x3 - x2), y1 + (y3 - y2)))
print(3)
for (x, y) in ans:
	print(x, y)


(a1, b1) = map(int, input().split())
(a2, b2) = map(int, input().split())
(a3, b3) = map(int, input().split())
print(3)
a4 = a1 + a2 - a3
b4 = b1 + b2 - b3
print(a4, b4)
a4 = a1 + a3 - a2
b4 = b1 + b3 - b2
print(a4, b4)
a4 = a3 + a2 - a1
b4 = b3 + b2 - b1
print(a4, b4)


a = tuple(map(int, input().split()))
b = tuple(map(int, input().split()))
c = tuple(map(int, input().split()))
print(3)

def middle(x, y):
	return ((x[0] + y[0]) / 2, (x[1] + y[1]) / 2)

def sym(a, o):
	return (int(2 * o[0] - a[0]), int(2 * o[1] - a[1]))
print(sym(c, middle(a, b))[0], sym(c, middle(a, b))[1])
print(sym(b, middle(a, c))[0], sym(b, middle(a, c))[1])
print(sym(a, middle(b, c))[0], sym(a, middle(b, c))[1])


(x1, y1) = input().split()
(x1, y1) = [int(x1), int(y1)]
(x2, y2) = input().split()
(x2, y2) = [int(x2), int(y2)]
(x3, y3) = input().split()
(x3, y3) = [int(x3), int(y3)]
ans = set()
abx = x1 - x2
aby = y1 - y2
bcx = x2 - x3
bcy = y2 - y3
acx = x1 - x3
acy = y1 - y3
x = x3 + abx
y = y3 + aby
ans.add((x, y))
x = x3 - abx
y = y3 - aby
ans.add((x, y))
x = x2 + acx
y = y2 + acy
ans.add((x, y))
x = x2 - acx
y = y2 - acy
ans.add((x, y))
x = x1 + bcx
y = y1 + bcy
ans.add((x, y))
x = x1 - bcx
y = y1 - bcy
ans.add((x, y))
print(len(ans))
for (x, y) in ans:
	print(x, y)


(x, y) = ([], [])
for i in range(3):
	(x_t, y_t) = map(int, input().split())
	x.append(x_t)
	y.append(y_t)
r = set()
r.add((x[2] + x[0] - x[1], y[2] + y[0] - y[1]))
r.add((x[2] + x[1] - x[0], y[2] + y[1] - y[0]))
r.add((x[0] + x[1] - x[2], y[0] + y[1] - y[2]))
r.add((x[0] + x[2] - x[1], y[0] + y[2] - y[1]))
r.add((x[1] + x[2] - x[0], y[1] + y[2] - y[0]))
r.add((x[1] + x[0] - x[2], y[1] + y[0] - y[2]))
print(len(r))
for i in r:
	print(i[0], i[1])


R = lambda : list(map(int, input().split()))
(a, b, c) = (R(), R(), R())

def r(a, b, c):
	return [a[0] + b[0] - c[0], a[1] + b[1] - c[1]]
print(3)
print(*r(a, b, c))
print(*r(b, c, a))
print(*r(c, a, b))


read = lambda : map(int, input().split())
v = lambda x1, x2: x2 - x1
x = [0] * 3
y = [0] * 3
(x[0], y[0]) = read()
(x[1], y[1]) = read()
(x[2], y[2]) = read()
ans = set()
from itertools import permutations
for perm in permutations([0, 1, 2]):
	(i, j, k) = perm
	xx = x[i] + v(x[i], x[j]) + v(x[i], x[k])
	yy = y[i] + v(y[i], y[j]) + v(y[i], y[k])
	ans.add((xx, yy))
print(len(ans))
[print(i, j) for (i, j) in ans]


def codeforces(points):
	result = set([])
	for point in points:
		(point_a, point_b) = [p for p in points if p != point]
		middle_point = ((point_a[0] + point_b[0]) / 2.0, (point_a[1] + point_b[1]) / 2.0)
		new_point = (str(int(2 * middle_point[0] - point[0])), str(int(2 * middle_point[1] - point[1])))
		result.add(new_point)
	return result
point_a = tuple(map(int, input().split()))
point_b = tuple(map(int, input().split()))
point_c = tuple(map(int, input().split()))
points = (point_a, point_b, point_c)
result = codeforces(points)
print(len(result))
for point in result:
	print(' '.join(point))


(x0, y0) = map(int, input().split())
(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(X, Y) = ([x0, x1, x2], [y0, y1, y2])
print(3)
for i in range(3):
	print(sum(X) - 2 * X[i], sum(Y) - 2 * Y[i])


def foo(p1, p2, p3):
	print(p1[0] + p2[0] - p3[0], p1[1] + p2[1] - p3[1])
p = []
for i in range(3):
	p.append(list(map(int, input().split())))
print(3)
foo(p[0], p[1], p[2])
foo(p[0], p[2], p[1])
foo(p[2], p[1], p[0])


from typing import List
INF = float('inf')
NINF = float('-inf')

def read_string():
	return input()

def read_string_line():
	return [x for x in input().split(' ')]

def read_int_line():
	return [int(x) for x in input().split(' ')]

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

def get_int_arr(s):
	return [int(x) for x in s.split()]

def get_sum(acc, l, r):
	return acc[r] - acc[l]
P = int(1000000000.0 + 7)

def exgcd(x, y):
	if y == 0:
		return (x, 1, 0)
	(g, a, b) = exgcd(y, x % y)
	t = x // y
	return (g, b, a - t * b)

def inv(x):
	(g, a, b) = exgcd(x, P)
	return a

def calc_acc(arr):
	ans = [0]
	for a in arr:
		ans.append(a + ans[-1])
	return ans
lines: List[str] = [*open(0)]
(x0, x1, x2) = [get_int_arr(s) for s in lines[:3]]

def solve(p0, p1, p2):
	print('%d %d' % (p0[0] + p1[0] - p2[0], p0[1] + p1[1] - p2[1]))
print(3)
solve(x0, x1, x2)
solve(x2, x1, x0)
solve(x0, x2, x1)


data = [list(map(int, input().split())) for i in range(3)]
print(3)
for i in range(3):
	print(data[i][0] + data[(i + 1) % 3][0] - data[(i + 2) % 3][0], data[i][1] + data[(i + 1) % 3][1] - data[(i + 2) % 3][1])


def plus(p1, p2):
	return [p1[0] + p2[0], p1[1] + p2[1]]

def vec(p1, p2):
	return [p2[0] - p1[0], p2[1] - p1[1]]

def pr(p):
	print(p[0], p[1])
(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
p1 = [x1, y1]
p2 = [x2, y2]
p3 = [x3, y3]
print(3)
pr(plus(plus(vec(p1, p2), vec(p1, p3)), p1))
pr(plus(plus(vec(p3, p1), vec(p3, p2)), p3))
pr(plus(plus(vec(p2, p1), vec(p2, p3)), p2))


a = [tuple(map(int, input().split())) for _ in range(3)]
print(3)
print(a[2][0] + a[0][0] - a[1][0], a[2][1] + a[0][1] - a[1][1])
print(a[0][0] + a[1][0] - a[2][0], a[0][1] + a[1][1] - a[2][1])
print(a[1][0] + a[2][0] - a[0][0], a[1][1] + a[2][1] - a[0][1])


def ri():
	return map(int, input().split())
(x1, y1) = ri()
(x2, y2) = ri()
(x3, y3) = ri()
print(3)
print(x2 - x1 + x3, y2 - y1 + y3)
print(x3 - x2 + x1, y3 - y2 + y1)
print(x1 - x3 + x2, y1 - y3 + y2)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
answer = []
answer.append([x2 - x1 + x3, y3 - y1 + y2])
answer.append([x1 - (x3 - x2), y2 + (y1 - y3)])
answer.append([x1 + (x3 - x2), y3 - (y2 - y1)])
print(3)
for i in answer:
	print(*i)


l = [list(map(int, input().split())) for i in range(3)]
print(3)
for i in range(3):
	a = l[i]
	b = l[(i + 1) % 3]
	c = l[i - 1]
	ab = [b[0] - a[0], b[1] - a[1]]
	ac = [c[0] - a[0], c[1] - a[1]]
	print(a[0] + ab[0] + ac[0], a[1] + ab[1] + ac[1])


x = []
y = []
for i in range(3):
	(a, b) = input().split()
	x.append(int(a))
	y.append(int(b))
print(3)
for i in range(3):
	print(str(sum(x) - 2 * x[i]) + ' ' + str(sum(y) - 2 * y[i]))


(ax, ay) = [int(x) for x in input().split()]
(bx, by) = [int(x) for x in input().split()]
(cx, cy) = [int(x) for x in input().split()]
print(3)
print(ax + bx - cx, ay + by - cy)
print(ax + cx - bx, ay + cy - by)
print(bx + cx - ax, by + cy - ay)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
print(3)
print(x1 + x2 - x3, ' ', y1 + y2 - y3)
print(x1 - x2 + x3, ' ', y1 - y2 + y3)
print(x3 + x2 - x1, ' ', y3 + y2 - y1)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
print(3)
a1 = y2 - y1
b1 = x1 - x2
c1 = y3 * x1 + y2 * x3 - y1 * x3 - y3 * x2
a2 = y3 - y2
b2 = x2 - x3
c2 = y1 * x2 + y3 * x1 - y1 * x3 - y2 * x1
a3 = y1 - y3
b3 = x3 - x1
c3 = y1 * x2 + y2 * x3 - y3 * x2 - y2 * x1
x = (c1 * b2 - c2 * b1) // (a1 * b2 - a2 * b1)
y = (c1 * a2 - c2 * a1) // (b1 * a2 - b2 * a1)
print(x, y)
x = (c3 * b2 - c2 * b3) // (a3 * b2 - a2 * b3)
y = (c3 * a2 - c2 * a3) // (b3 * a2 - b2 * a3)
print(x, y)
x = (c3 * b1 - c1 * b3) // (a3 * b1 - a1 * b3)
y = (c3 * a1 - c1 * a3) // (b3 * a1 - b1 * a3)
print(x, y)


def mm(x1, y1, x2, y2, x3, y3):
	xm = (x1 + x2) / 2
	ym = (y1 + y2) / 2
	x = xm * 2 - x3
	y = ym * 2 - y3
	return (int(x), int(y))
(x1, y1) = [int(i) for i in input().split()]
(x2, y2) = [int(i) for i in input().split()]
(x3, y3) = [int(i) for i in input().split()]
s = set()
s.add(mm(x1, y1, x2, y2, x3, y3))
s.add(mm(x3, y3, x2, y2, x1, y1))
s.add(mm(x1, y1, x3, y3, x2, y2))
print(len(s))
for i in s:
	print(i[0], i[1])


import math
import collections
import bisect

def arrPrint(a):
	return ' '.join([str(i) for i in a])

def gridPrint(a):
	return '\n'.join([' '.join([str(j) for j in a[i]]) for i in range(len(a))])

def isPalindrome(s):
	for i in range(len(s) // 2):
		if not s[i] == s[-i - 1]:
			return False
	return True

def solve(points):
	new = []
	for i in range(3):
		newX = points[i][0]
		newY = points[i][1]
		for j in range(3):
			if not i == j:
				newX += points[j][0] - points[i][0]
				newY += points[j][1] - points[i][1]
		new.append([newX, newY])
	print(3)
	for i in range(3):
		print(arrPrint(new[i]))
points = []
for i in range(3):
	points.append([int(s) for s in input().split()])
solve(points)


cord = []
for i in range(3):
	(x, y) = map(int, input().split())
	c = []
	c.append(x)
	c.append(y)
	cord.append(c)
res = {}
vx = cord[2][0] - cord[0][0]
vy = cord[2][1] - cord[0][1]
res[cord[1][0] + vx, cord[1][1] + vy] = str(cord[1][0] + vx) + ' ' + str(cord[1][1] + vy)
vx = cord[0][0] - cord[2][0]
vy = cord[0][1] - cord[2][1]
res[cord[1][0] + vx, cord[1][1] + vy] = str(cord[1][0] + vx) + ' ' + str(cord[1][1] + vy)
vx = cord[2][0] - cord[1][0]
vy = cord[2][1] - cord[1][1]
res[cord[0][0] + vx, cord[0][1] + vy] = str(cord[0][0] + vx) + ' ' + str(cord[0][1] + vy)
vx = cord[1][0] - cord[2][0]
vy = cord[1][1] - cord[2][1]
res[cord[0][0] + vx, cord[0][1] + vy] = str(cord[0][0] + vx) + ' ' + str(cord[0][1] + vy)
vx = cord[1][0] - cord[0][0]
vy = cord[1][1] - cord[0][1]
res[cord[2][0] + vx, cord[2][1] + vy] = str(cord[2][0] + vx) + ' ' + str(cord[2][1] + vy)
vx = cord[0][0] - cord[1][0]
vy = cord[0][1] - cord[1][1]
res[cord[2][0] + vx, cord[2][1] + vy] = str(cord[2][0] + vx) + ' ' + str(cord[2][1] + vy)
val = list(res.values())
print(len(val))
for i in range(len(val)):
	print(val[i])


l1 = []
for i in range(3):
	l1.append([int(s) for s in input().split()])
x1 = l1[2][0] - l1[0][0] + l1[1][0]
y1 = l1[2][1] - l1[0][1] + l1[1][1]
x2 = l1[2][0] - l1[1][0] + l1[0][0]
y2 = l1[2][1] - l1[1][1] + l1[0][1]
x3 = -1 * l1[2][0] + l1[0][0] + l1[1][0]
y3 = -1 * l1[2][1] + l1[0][1] + l1[1][1]
print(3)
print(x1, y1)
print(x2, y2)
print(x3, y3)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
ans = set(())
ans.add((x3 + x1 - x2, y3 + y1 - y2))
ans.add((x3 + x2 - x1, y3 + y2 - y1))
ans.add((x2 + x3 - x1, y2 + y3 - y1))
ans.add((x2 + x1 - x3, y2 + y1 - y3))
ans.add((x1 + x3 - x2, y1 + y3 - y2))
ans.add((x1 + x2 - x3, y1 + y2 - y3))
print(len(ans))
for i in ans:
	print(' '.join((str(j) for j in i)), end='\n')


[x1, y1] = [int(x) for x in input().split()]
[x2, y2] = [int(x) for x in input().split()]
[x3, y3] = [int(x) for x in input().split()]
print(3)
print(x3 + x1 - x2, y3 + y1 - y2)
print(x3 + x2 - x1, y3 + y2 - y1)
print(x1 + x2 - x3, y1 + y2 - y3)


c = [[int(i) for i in input().split()] for i in range(3)]
s = set()
s.add((c[0][0] + c[1][0] - c[2][0], c[0][1] + c[1][1] - c[2][1]))
s.add((c[0][0] - c[1][0] + c[2][0], c[0][1] - c[1][1] + c[2][1]))
s.add((c[1][0] + c[0][0] - c[2][0], c[1][1] + c[0][1] - c[2][1]))
s.add((c[1][0] - c[0][0] + c[2][0], c[1][1] - c[0][1] + c[2][1]))
s.add((c[2][0] + c[1][0] - c[0][0], c[2][1] + c[1][1] - c[0][1]))
s.add((c[2][0] - c[1][0] + c[0][0], c[2][1] - c[1][1] + c[0][1]))
print(len(s))
for (a, b) in s:
	print(a, b)


(x, y) = map(int, input().split())
(a, b) = map(int, input().split())
(p, q) = map(int, input().split())
print(3)
print(x + p - a, y + q - b)
print(x + a - p, y + b - q)
print(a + p - x, b + q - y)


xarr = list()
yarr = list()
xsum = 0
ysum = 0
for i in range(3):
	(x, y) = map(int, input().split())
	xarr.append(x)
	yarr.append(y)
	xsum += x
	ysum += y
print(3)
for i in range(3):
	print(xsum - 2 * xarr[i], ysum - 2 * yarr[i])


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
points = []
points.append([x1 + x2 - x3, y1 + y2 - y3])
if [x2 + x3 - x1, y2 + y3 - y1] not in points:
	points.append([x2 + x3 - x1, y2 + y3 - y1])
if [x3 + x1 - x2, y3 + y1 - y2] not in points:
	points.append([x3 + x1 - x2, y3 + y1 - y2])
print(len(points))
for m in points:
	print(m[0], m[1])


a = []
b = []
for i in range(3):
	(x, y) = map(int, input().split())
	a.append(x)
	b.append(y)
print(3)
for i in range(3):
	for j in range(i + 1, 3):
		print(a[i] + a[j] - a[3 - i - j], b[i] + b[j] - b[3 - i - j])


class Point:

	def __init__(self, x, y):
		self.x = x
		self.y = y

def f(a, b, p):
	dx = a.x - p.x
	dy = a.y - p.y
	return Point(b.x + dx, b.y + dy)
l = []
for _ in range(3):
	l.append(Point(*map(int, input().split())))
answ = []
answ.append(f(l[0], l[1], l[2]))
answ.append(f(l[0], l[2], l[1]))
answ.append(f(l[1], l[2], l[0]))
print(len(answ))
for i in answ:
	print(i.x, i.y)


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
from heapq import *
from math import gcd, factorial, floor, ceil
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
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):
	(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))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for pp in range(t):
		solve(pp)

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def google(p):
	print('Case #' + str(p) + ': ', end='')

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

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
inf = pow(10, 20)
mod = 998244353

def solve(case):
	p = []
	for i in range(3):
		(x, y) = sep()
		p.append((x, y))
	ans = []
	for i in range(3):
		x = p[i % 3][0] + p[(i + 1) % 3][0] - p[(i + 2) % 3][0]
		y = p[i % 3][1] + p[(i + 1) % 3][1] - p[(i + 2) % 3][1]
		ans.append((x, y))
	print(len(ans))
	for i in range(len(ans)):
		print(*ans[i])
testcase(1)


a = []
mp = {}
(ax, ay) = map(int, input().split())
(bx, by) = map(int, input().split())
(cx, cy) = map(int, input().split())
(mp[ax, ay], mp[bx, by], mp[cx, cy]) = (True, True, True)
(dx, dy) = (0, 0)
if not mp.get((bx + cx - ax, by + cy - ay)):
	mp[bx + cx - ax, by + cy - ay] = True
	a.append(bx + cx - ax)
	a.append(by + cy - ay)
(bx, by, cx, cy) = (cx, cy, bx, by)
if not mp.get((bx + cx - ax, by + cy - ay)):
	mp[bx + cx - ax, by + cy - ay] = True
	a.append(bx + cx - ax)
	a.append(by + cy - ay)
(ax, ay, cx, cy) = (cx, cy, ax, ay)
if not mp.get((bx + cx - ax, by + cy - ay)):
	mp[bx + cx - ax, by + cy - ay] = True
	a.append(bx + cx - ax)
	a.append(by + cy - ay)
(bx, by, ax, ay) = (ax, ay, bx, by)
if not mp.get((bx + cx - ax, by + cy - ay)):
	mp[bx + cx - ax, by + cy - ay] = True
	a.append(bx + cx - ax)
	a.append(by + cy - ay)
(bx, by, cx, cy) = (cx, cy, bx, by)
if not mp.get((bx + cx - ax, by + cy - ay)):
	mp[bx + cx - ax, by + cy - ay] = True
	a.append(bx + cx - ax)
	a.append(by + cy - ay)
(ax, ay, cx, cy) = (cx, cy, ax, ay)
if not mp.get((bx + cx - ax, by + cy - ay)):
	mp[bx + cx - ax, by + cy - ay] = True
	a.append(bx + cx - ax)
	a.append(by + cy - ay)
print(len(a) // 2)
for i in range(0, len(a), 2):
	print(a[i], a[i + 1])


(x1, y1) = [int(x) for x in input().split()]
(x2, y2) = [int(x) for x in input().split()]
(x3, y3) = [int(x) for x in input().split()]
print(3)
middlex = min(x2, x3) + (max(x2, x3) - min(x2, x3)) / 2
middley = min(y2, y3) + (max(y2, y3) - min(y2, y3)) / 2
print(int(middlex + middlex - x1), int(2 * middley - y1))
middlex = min(x1, x3) + (max(x1, x3) - min(x1, x3)) / 2
middley = min(y1, y3) + (max(y1, y3) - min(y1, y3)) / 2
print(int(middlex + middlex - x2), int(2 * middley - y2))
middlex = min(x2, x1) + (max(x2, x1) - min(x2, x1)) / 2
middley = min(y2, y1) + (max(y2, y1) - min(y2, y1)) / 2
print(int(middlex + middlex - x3), int(2 * middley - y3))


x = []
y = []
for i in range(3):
	(a, b) = map(int, input().split())
	x.append(a)
	y.append(b)
print(3)
print(x[1] - x[2] + x[0], y[1] - y[2] + y[0])
print(x[1] + x[2] - x[0], y[1] + y[2] - y[0])
print(-x[1] + x[2] + x[0], -y[1] + y[2] + y[0])


l = []
for i in range(3):
	l.append(list(map(int, input().split())))
for i in range(2):
	l.append(l[i])
print(3)
for i in range(3):
	print(l[i][0] + l[i + 2][0] - l[i + 1][0], end=' ')
	print(l[i][1] + l[i + 2][1] - l[i + 1][1])


(ax, ay) = [int(i) for i in input().split()]
(bx, by) = [int(i) for i in input().split()]
(cx, cy) = [int(i) for i in input().split()]
a = bx - ax
b = by - ay
c = cx - ax
d = cy - ay
if a * d - b * c == 0:
	print(0)
else:
	print(3)
	print(ax + bx - cx, ay + by - cy)
	print(ax + cx - bx, ay + cy - by)
	print(cx + bx - ax, cy + by - ay)


x = []
y = []
for i in range(3):
	raw = input().split()
	x.append(int(raw[0]))
	y.append(int(raw[1]))
dX = x[1] - x[0]
dY = y[1] - y[0]
points = set()
points.add((x[2] + dX, y[2] + dY))
points.add((x[2] - dX, y[2] - dY))
dX = x[2] - x[1]
dY = y[2] - y[1]
points.add((x[0] + dX, y[0] + dY))
points.add((x[0] - dX, y[0] - dY))
print(len(points))
for x in points:
	print(x[0], end=' ')
	print(x[1])


def find_d(a, b, c):
	bc = (c[0] - b[0], c[1] - b[1])
	d = (a[0] + bc[0], a[1] + bc[1])
	return d
a = tuple(map(int, input().strip().split()))
b = tuple(map(int, input().strip().split()))
c = tuple(map(int, input().strip().split()))
print(3)
print(' '.join([str(x) for x in find_d(a, b, c)]))
print(' '.join([str(x) for x in find_d(c, a, b)]))
print(' '.join([str(x) for x in find_d(b, c, a)]))


def READ():
	return map(int, input().split())
(x, y) = READ()
(a, b) = READ()
(c, d) = READ()
print('3')
print(a + x - c, b + y - d)
print(c + x - a, d + y - b)
print(c + a - x, b + d - y)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
print(3)
d1 = []
d1.append((x3 - (x1 - x2), y3 - (y1 - y2)))
d1.append((x3 - (x2 - x1), y3 + (y1 - y2)))
d1.append((x2 - (x1 - x3), y2 - (y1 - y3)))
d1.append((x2 + (x1 - x3), y2 + (y1 - y3)))
d1.append((x1 - (x2 - x3), y1 - (y2 - y3)))
d1.append((x1 + (x2 - x3), y1 + (y2 - y3)))
d1 = set(d1)
for i in d1:
	print(i[0], i[1])


from itertools import permutations
lexa_par = []
for i in range(3):
	(x, y) = input().split()
	(x, y) = (int(x), int(y))
	lexa_par.append((x, y))
possible_solutions = set()
for p in permutations(lexa_par):
	(x0, y0) = p[0]
	(x1, y1) = p[1]
	(x2, y2) = p[2]
	x3 = x0 + x2 - x1
	y3 = y0 + y2 - y1
	possible_solutions.add((x3, y3))
print(len(possible_solutions))
for p in possible_solutions:
	print(*p)


import os
import sys, math
from io import BytesIO, IOBase

def main():
	t = 1
	for case in range(t):
		(x1, y1) = list(map(int, input().split()))
		(x2, y2) = list(map(int, input().split()))
		(x3, y3) = list(map(int, input().split()))
		print(3)
		x4 = x1 + x2 - x3
		y4 = y1 + y2 - y3
		print(x4, y4)
		x4 = x2 + x3 - x1
		y4 = y2 + y3 - y1
		print(x4, y4)
		x4 = x1 + x3 - x2
		y4 = y1 + y3 - y2
		print(x4, y4)
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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


(x, y) = map(int, input().split())
(a, b) = map(int, input().split())
(c, d) = map(int, input().split())
print(3)
print(a + x - c, b + y - d)
print(c + x - a, d + y - b)
print(c + a - x, b + d - y)


p = []
for i in range(3):
	p.append(list(map(int, input().split())))
print(3)
print(p[0][0] + p[1][0] - p[2][0], p[0][1] + p[1][1] - p[2][1])
print(p[0][0] + p[2][0] - p[1][0], p[0][1] + p[2][1] - p[1][1])
print(p[1][0] + p[2][0] - p[0][0], p[1][1] + p[2][1] - p[0][1])


def input_data():
	list = []
	for x in range(0, 3):
		(x, y) = map(int, input().split(' '))
		point = [x, y]
		list.append(point)
	return list

def get_point(point1, point2, point3):
	(x1, y1) = point1
	(x2, y2) = point2
	(x3, y3) = point3
	(x4, y4) = (0, 0)
	x0 = (x1 - x2) / 2 + x2
	y0 = (y1 - y2) / 2 + y2
	x4 = x0 - x3 + x0
	y4 = y0 - y3 + y0
	return [int(x4), int(y4)]

def print_list(points):
	print(len(points))
	for point in points:
		print(str(point[0]) + ' ' + str(point[1]))
list = input_data()
points = []
points.append(get_point(list[0], list[1], list[2]))
points.append(get_point(list[0], list[2], list[1]))
points.append(get_point(list[1], list[2], list[0]))
print_list(points)


(x1, y1) = list(map(int, input().split()))
(x2, y2) = list(map(int, input().split()))
(x3, y3) = list(map(int, input().split()))
line = []
x41 = x3 - (x2 - x1)
y41 = y3 - (y2 - y1)
line += [[x41, y41]]
x41 = x3 - (x1 - x2)
y41 = y3 - (y1 - y2)
line += [[x41, y41]]
x41 = x1 - (x2 - x3)
y41 = y1 - (y2 - y3)
line += [[x41, y41]]
x41 = x1 - (x3 - x2)
y41 = y1 - (y3 - y2)
line += [[x41, y41]]
x41 = x2 - (x1 - x3)
y41 = y2 - (y1 - y3)
line += [[x41, y41]]
x41 = x2 - (x3 - x1)
y41 = y2 - (y3 - y1)
line += [[x41, y41]]
line1 = [line[0]]
for i in range(1, 5):
	good = False
	for j in range(len(line1)):
		if line[i] == line1[j]:
			good = True
	if not good:
		line1 += [line[i]]
print(len(line1))
for i in range(len(line1)):
	print(' '.join(map(str, line1[i])))


(x1, x2) = map(int, input().split())
(x3, x4) = map(int, input().split())
(x5, x6) = map(int, input().split())
print(3)
print(x3 - x1 + x5, x4 - x2 + x6)
print(x1 - x3 + x5, x2 - x4 + x6)
print(x3 - x5 + x1, x4 - x6 + x2)


(p1x, p1y) = map(int, input().split())
(p2x, p2y) = map(int, input().split())
(p3x, p3y) = map(int, input().split())
print(3)
print(p2x + p3x - p1x, p2y + p3y - p1y)
print(p1x + p2x - p3x, p1y + p2y - p3y)
print(p1x + p3x - p2x, p1y + p3y - p2y)


X = [None] * 3
for i in range(3):
	X[i] = tuple((int(x) for x in input().split()))
print(3)
print(X[0][0] + X[1][0] - X[2][0], X[0][1] + X[1][1] - X[2][1])
print(-X[0][0] + X[1][0] + X[2][0], -X[0][1] + X[1][1] + X[2][1])
print(X[0][0] - X[1][0] + X[2][0], X[0][1] - X[1][1] + X[2][1])


MAXC = 1000
MINC = -1000

def solve():
	xy = []
	for _ in range(3):
		xy.append(tuple(map(int, input().split())))
	(a, b, c) = xy
	ac = (a[0] - c[0], a[1] - c[1])
	bc = (b[0] - c[0], b[1] - c[1])
	points = set()
	points.add((a[0] - bc[0], a[1] - bc[1]))
	points.add((a[0] + bc[0], a[1] + bc[1]))
	points.add((b[0] - ac[0], b[1] - ac[1]))
	points.add((b[0] + ac[0], b[1] + ac[1]))
	real_points = []
	for (x, y) in points:
		if int(x) == x and int(y) == y:
			real_points.append((x, y))
	return '{}\n{}'.format(len(real_points), '\n'.join(['{} {}'.format(x, y) for (x, y) in real_points]))
print(solve())


a = list(map(int, input().split()))
x1 = a[0]
y1 = a[1]
a = list(map(int, input().split()))
x2 = a[0]
y2 = a[1]
a = list(map(int, input().split()))
x3 = a[0]
y3 = a[1]
print(3)
print(x1 + x2 - x3, y1 + y2 - y3)
print(x1 + x3 - x2, y1 + y3 - y2)
print(x3 + x2 - x1, y2 + y3 - y1)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
pts = [(x1, y1), (x2, y2), (x3, y3)]
xs = sum((p[0] for p in pts))
ys = sum((p[1] for p in pts))
print(3)
for p in pts:
	print(xs - 2 * p[0], ys - 2 * p[1])


points = []
for i in range(3):
	points.append(tuple(map(int, input().split())))
ans = set()
for i in range(3):
	for j in range(3):
		if i == j:
			continue
		vector = (points[j][0] - points[i][0], points[j][1] - points[i][1])
		third = 0 + 1 + 2 - i - j
		ans.add((points[third][0] + vector[0], points[third][1] + vector[1]))
print(len(ans))
for (a, b) in ans:
	print(a, b)


a = list()
for i in range(3):
	a.append(tuple(map(int, input().split())))
print(3)
for i in range(3):
	j = (i + 1) % 3
	k = (i + 2) % 3
	dx = a[j][0] + a[k][0] - a[i][0]
	dy = a[k][1] + a[j][1] - a[i][1]
	print(dx, dy)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
ans = set()
x4 = x3 + (x1 - x2)
y4 = y3 - (y2 - y1)
x5 = x3 - (x1 - x2)
y5 = y3 + (y2 - y1)
x6 = x1 - (x3 - x2)
y6 = y1 - (y3 - y2)
ans.add((x4, y4))
ans.add((x5, y5))
ans.add((x6, y6))
print(len(ans))
for i in ans:
	print(*i)


points = []
for i in range(3):
	p = input().split()
	points.append(tuple(map(int, p)))
results = set()
for i in range(3):
	for j in range(3):
		if i == j:
			continue
		dx = points[i][0] - points[j][0]
		dy = points[i][1] - points[j][1]
		p = 3 - i - j
		results.add((points[p][0] + dx, points[p][1] + dy))
		results.add((points[p][0] - dx, points[p][1] - dy))
print(len(results))
for point in results:
	print('{} {}'.format(point[0], point[1]))


cases = input().split()
x1 = int(cases[0])
y1 = int(cases[1])
cases = input().split()
x2 = int(cases[0])
y2 = int(cases[1])
cases = input().split()
x3 = int(cases[0])
y3 = int(cases[1])
answer = set()
v1 = (x1 - x2, y1 - y2)
v2 = (x1 - x3, y1 - y3)
v3 = (x2 - x3, y2 - y3)
v4 = (x2 - x1, y2 - y1)
a1 = (v1[0] + x3, v1[1] + y3)
a2 = (v2[0] + x2, v2[1] + y2)
a3 = (v3[0] + x1, v3[1] + y1)
a4 = (v4[0] + x3, v4[1] + y3)
answer.add(a1)
answer.add(a2)
answer.add(a3)
answer.add(a4)
print(3)
for i in range(len(answer)):
	res = answer.pop()
	print('{} {}'.format(res[0], res[1]))


(Ax, Ay) = [int(x) for x in input().split()]
(Bx, By) = [int(x) for x in input().split()]
(Cx, Cy) = [int(x) for x in input().split()]
r = Ax - Bx
Dx = Cx - r
q = Ay - By
Dy = Cy - q
print('3')
print(Dx, Dy)
r = Ax - Bx
Dx = Cx + r
q = Ay - By
Dy = Cy + q
print(Dx, Dy)
r = Cx - Bx
Dx = Ax - r
q = Cy - By
Dy = Ay - q
print(Dx, Dy)


a = []
for i in range(3):
	a.append([int(i) for i in input().split()])
c = []
for i in range(3):
	(j, k) = list({0, 1, 2} - {i})
	c.append((a[i][0] + a[j][0] - a[k][0], a[i][1] + a[j][1] - a[k][1]))
	c.append((a[i][0] + a[k][0] - a[j][0], a[i][1] + a[k][1] - a[j][1]))
print(len(set(c)))
for i in set(c):
	print(*i)


(ax, ay) = map(int, input().split())
(bx, by) = map(int, input().split())
(cx, cy) = map(int, input().split())
print(3)
print(bx + cx - ax, by + cy - ay)
print(ax + cx - bx, ay + cy - by)
print(ax + bx - cx, ay + by - cy)


import sys
import os

def changeStdioToFile():
	path = os.path.dirname(os.path.abspath(__file__))
	sys.stdin = open(f'{path}/input.txt', 'r')
	sys.stdout = open(f'{path}/output.txt', 'w')
t = 1
for _ in range(t):
	(x1, y1) = [int(x) for x in input().split()]
	(x2, y2) = [int(x) for x in input().split()]
	(x3, y3) = [int(x) for x in input().split()]
	print(3)
	print(x3 + (x1 - x2), y3 + (y1 - y2))
	print(x2 + (x3 - x1), y2 + (y3 - y1))
	print(x1 + (x2 - x3), y1 + (y2 - y3))


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
(a1, b1) = (x1 + (x3 - x2), y1 + (y3 - y2))
(a2, b2) = (x1 - (x3 - x2), y1 - (y3 - y2))
(a3, b3) = (x2 + (x3 - x1), y2 + (y3 - y1))
print(3)
print(a1, b1)
print(a2, b2)
print(a3, b3)


a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
print(3)
e = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
print(int(2 * e[0] - c[0]), int(2 * e[1] - c[1]))
e = [(a[0] + c[0]) / 2, (a[1] + c[1]) / 2]
print(int(2 * e[0] - b[0]), int(2 * e[1] - b[1]))
e = [(b[0] + c[0]) / 2, (b[1] + c[1]) / 2]
print(int(2 * e[0] - a[0]), int(2 * e[1] - a[1]))


points = []
for i in range(3):
	points.append(tuple(map(int, input().split())))
d = (points[0][0] - points[1][0], points[0][1] - points[1][1])
print(3)
p1 = tuple(map(sum, zip(points[2], d)))
print(p1[0], p1[1])
p2 = tuple(map(sum, zip(points[2], map(lambda x: -x, d))))
print(p2[0], p2[1])
d = (points[1][0] - points[2][0], points[1][1] - points[2][1])
p3 = tuple(map(sum, zip(points[0], d)))
print(p3[0], p3[1])


import math
import sys
xy = []
for i in range(3):
	xy.append(list(map(int, input().split())))
print(3)
v = [[xy[2][0] - xy[1][0], xy[2][1] - xy[1][1]], [xy[0][0] - xy[2][0], xy[0][1] - xy[2][1]], [xy[1][0] - xy[0][0], xy[1][1] - xy[0][1]]]
for i in range(3):
	print(xy[i][0] + v[i][0], xy[i][1] + v[i][1])


(a, b) = map(int, input().split())
(a1, b1) = map(int, input().split())
(a2, b2) = map(int, input().split())
print(3)
print(a + a1 - a2, b + b1 - b2)
print(a + a2 - a1, b - b1 + b2)
print(a2 + a1 - a, b1 + b2 - b)


points = [list(map(int, input().split())) for _ in range(3)]
print(3)
for i in range(3):
	(x, y) = points[i]
	(x_s, y_s) = points[(i + 1) % 3]
	(x_e, y_e) = points[(i + 2) % 3]
	mid_x = (x_s + x_e) / 2
	mid_y = (y_s + y_e) / 2
	x -= mid_x
	y -= mid_y
	x *= -1
	y *= -1
	x += mid_x
	y += mid_y
	print(int(x), int(y))


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
x4 = x1 + x2 - x3
y4 = y1 + y2 - y3
x5 = x3 + x2 - x1
y5 = y3 + y2 - y1
x6 = x1 + x3 - x2
y6 = y1 + y3 - y2
len = 1
ans = []
ans.append([x4, y4])
if x5 != x4 or y4 != y5:
	len += 1
	ans.append([x5, y5])
if x6 != x5 and x6 != x4 or (y6 != y5 and y6 != y4):
	len += 1
	ans.append([x6, y6])
print(len)
for i in range(len):
	print(*ans[i])


(a, b) = map(int, input().split())
(c, d) = map(int, input().split())
(e, f) = map(int, input().split())
print(3)
print(str(a + c - e) + ' ' + str(b + d - f))
print(str(a - c + e) + ' ' + str(b - d + f))
print(str(-a + c + e) + ' ' + str(-b + d + f))


data = [[0, 0], [0, 0], [0, 0]]
data[0] = [int(x) for x in input().split()]
data[1] = [int(x) for x in input().split()]
data[2] = [int(x) for x in input().split()]
v1 = [data[1][0] - data[0][0], data[1][1] - data[0][1]]
v2 = [data[2][0] - data[0][0], data[2][1] - data[0][1]]
v3 = [data[1][0] - data[2][0], data[1][1] - data[2][1]]
data_n = set()
data_n.add((data[2][0] + v1[0], data[2][1] + v1[1]))
data_n.add((data[2][0] - v1[0], data[2][1] - v1[1]))
data_n.add((data[1][0] + v2[0], data[1][1] + v2[1]))
data_n.add((data[1][0] - v2[0], data[1][1] - v2[1]))
data_n.add((data[0][0] + v3[0], data[0][1] + v3[1]))
data_n.add((data[0][0] - v3[0], data[0][1] - v3[1]))
print(len(data_n))
for i in data_n:
	print(*i)


import sys
arr = [list(map(int, next(sys.stdin).split())) for i in range(3)]

def add(a, b):
	return [a[i] + b[i] for i in range(2)]

def sub(a, b):
	return [a[i] - b[i] for i in range(2)]

def div(a, b):
	return [a[i] / b for i in range(2)]
a = add(arr[0], sub(arr[1], arr[2]))
b = add(arr[2], sub(arr[1], arr[0]))
c = add(arr[0], sub(arr[2], arr[1]))
print(3)
print('%d %d' % tuple(a))
print('%d %d' % tuple(b))
print('%d %d' % tuple(c))


def main():
	try:
		while True:
			(x0, y0) = map(int, input().split())
			(x1, y1) = map(int, input().split())
			(x2, y2) = map(int, input().split())
			print(3)
			print(x1 + x2 - x0, y1 + y2 - y0)
			print(x0 + x1 - x2, y0 + y1 - y2)
			print(x0 + x2 - x1, y0 + y2 - y1)
	except EOFError:
		pass
main()


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
ans = []
dx = x1 - x2
dy = y1 - y2
ans.append((x3 + dx, y3 + dy))
ans.append((x3 - dx, y3 - dy))
dx = x1 - x3
dy = y1 - y3
if (x2 + dx, y2 + dy) not in ans:
	ans.append((x2 + dx, y2 + dy))
if (x2 - dx, y2 - dy) not in ans:
	ans.append((x2 - dx, y2 - dy))
dx = x2 - x3
dy = y2 - y3
if (x1 + dx, y1 + dy) not in ans:
	ans.append((x1 + dx, y1 + dy))
if (x1 - dx, y1 - dy) not in ans:
	ans.append((x1 - dx, y1 - dy))
print(len(ans))
for el in ans:
	print(*el)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
x = [x1, x2, x3]
y = [y1, y2, y3]
print(3)
for i in range(3):
	print(str(x[i] - x[(i + 1) % 3] + x[(i + 2) % 3]) + ' ' + str(y[i] - y[(i + 1) % 3] + y[(i + 2) % 3]))


(x1, y1) = (int(z) for z in input().split())
(x2, y2) = (int(z) for z in input().split())
(x3, y3) = (int(z) for z in input().split())
v1x = x2 - x1
v1y = y2 - y1
v2x = x3 - x1
v2y = y3 - y1
print(3)
print(x1 + v1x + v2x, y1 + v1y + v2y)
print(x1 + v1x - v2x, y1 + v1y - v2y)
print(x1 - v1x + v2x, y1 - v1y + v2y)


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())

def mirror(x1, y1, x2, y2, x3, y3):
	x_mid = (x1 + x2) / 2
	if x3 < x_mid:
		x3 += 2 * (x_mid - x3)
	else:
		x3 -= 2 * (x3 - x_mid)
	y_mid = (y1 + y2) / 2
	if y3 < y_mid:
		y3 += 2 * (y_mid - y3)
	else:
		y3 -= 2 * (y3 - y_mid)
	return (x3, y3)
answer = []
(x, y) = mirror(x1, y1, x2, y2, x3, y3)
if int(x) == x and int(y) == y:
	answer.append([x, y])
(x, y) = mirror(x1, y1, x3, y3, x2, y2)
if int(x) == x and int(y) == y:
	answer.append([x, y])
(x, y) = mirror(x3, y3, x2, y2, x1, y1)
if int(x) == x and int(y) == y:
	answer.append([x, y])
print(len(answer))
for i in answer:
	print(int(i[0]), int(i[1]))


points = []
for i in range(3):
	points.append(list(map(int, input().split())))

def get4(a, b, c):
	return [b[0] + c[0] - a[0], b[1] + c[1] - a[1]]
print(3)
for i in range(3):
	points = points[1:] + [points[0]]
	print(' '.join(map(str, get4(*points))))


xy = [list(map(int, input().split())) for _ in range(3)]
ans = set([(xy[0][0] + xy[1][0] - xy[2][0], xy[0][1] + xy[1][1] - xy[2][1]), (xy[0][0] - xy[1][0] + xy[2][0], xy[0][1] - xy[1][1] + xy[2][1]), (-xy[0][0] + xy[1][0] + xy[2][0], -xy[0][1] + xy[1][1] + xy[2][1])])
print(len(ans))
for x in ans:
	print(*x)


a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
points = []
xp = a[0] - c[0]
yp = a[1] - c[1]
points.append([b[0] + xp, b[1] + yp])
points.append([b[0] - xp, b[1] - yp])
xp = a[0] - b[0]
yp = a[1] - b[1]
points.append([c[0] + xp, c[1] + yp])
points.append([c[0] - xp, c[1] - yp])
xp = b[0] - c[0]
yp = b[1] - c[1]
points.append([a[0] + xp, a[1] + yp])
points.append([a[0] - xp, a[1] - yp])
points.sort()
np = [points[i] for i in range(len(points)) if i == 0 or points[i] != points[i - 1]]
print(len(np))
for i in np:
	print(i[0], i[1])


points = []
for i in range(3):
	(a, b) = list(map(int, input().split()))
	points.append((a, b))
a = points[0]
b = points[1]
c = points[2]
res1 = (b[0] + c[0] - a[0], b[1] + c[1] - a[1])
res2 = (a[0] + b[0] - c[0], a[1] + b[1] - c[1])
res3 = (a[0] + c[0] - b[0], a[1] + c[1] - b[1])
results = list(set(list((res1, res2, res3))))
print(len(results))
for i in range(len(results)):
	print(results[i][0], results[i][-1])


def main():
	x = [0 for _ in range(3)]
	y = [0 for _ in range(3)]
	for i in range(3):
		(x[i], y[i]) = map(int, input().split())
	print(3)
	for i in range(3):
		dx = x[(i + 1) % 3] - x[i]
		dy = y[(i + 1) % 3] - y[i]
		X = x[(i + 2) % 3] + dx
		Y = y[(i + 2) % 3] + dy
		print('{0} {1}'.format(X, Y))
main()


def f(p1, p2, p3):
	o = ((p2[0] + p3[0]) // 2, (p2[1] + p3[1]) // 2)
	dx = o[0] - p1[0]
	dy = o[1] - p1[1]
	res = (p1[0] // 2 + dx, p1[1] // 2 + dy)
	return res

def main():
	p1 = tuple([int(x) * 2 for x in input().split()])
	p2 = tuple([int(x) * 2 for x in input().split()])
	p3 = tuple([int(x) * 2 for x in input().split()])
	d2 = (p2[0] - p1[0], p2[1] - p1[1])
	d3 = (p3[0] - p1[0], p3[1] - p1[1])
	if d2[0] * d3[1] - d2[1] * d3[0] == 0:
		print(0)
		return
	res = set()
	res.add(f(p1, p2, p3))
	res.add(f(p2, p1, p3))
	res.add(f(p3, p2, p1))
	print(len(res))
	for p in res:
		print(' '.join(map(str, p)))

def __starting_point():
	main()
__starting_point()


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
(ansx1, ansy1) = (x1 + (x2 - x3), y1 + (y2 - y3))
(ansx2, ansy2) = (x2 + (x3 - x1), y2 + (y3 - y1))
(ansx3, ansy3) = (x3 + (x1 - x2), y3 + (y1 - y2))
print(3)
print(ansx1, ansy1)
print(ansx2, ansy2)
print(ansx3, ansy3)


(xa, ya) = map(int, input().split())
(xb, yb) = map(int, input().split())
(xc, yc) = map(int, input().split())
print(3)
print(xa + xb - xc, ya + yb - yc)
print(xb + xc - xa, yb + yc - ya)
print(xc + xa - xb, yc + ya - yb)


IL = lambda : list(map(int, input().split()))
IS = lambda : input().split()
I = lambda : int(input())
S = lambda : input()
points = [IL() for i in range(3)]
ans = []
ans.append([points[0][0] - points[1][0] + points[2][0], points[0][1] - points[1][1] + points[2][1]])
ans.append([points[1][0] - points[2][0] + points[0][0], points[1][1] - points[2][1] + points[0][1]])
ans.append([points[2][0] - points[0][0] + points[1][0], points[2][1] - points[0][1] + points[1][1]])
print(3)
for point in ans:
	print(point[0], point[1])


I = lambda : map(int, input().split())
(x1, y1) = I()
(x2, y2) = I()
(x3, y3) = I()
(A, B, C) = (complex(x1, y1), complex(x2, y2), complex(x3, y3))
print(3)
print(int((B + C - A).real), int((B + C - A).imag))
print(int((A + B - C).real), int((A + B - C).imag))
print(int((A + C - B).real), int((A + C - B).imag))


(q, w) = map(int, input().split())
(a, s) = map(int, input().split())
(z, x) = map(int, input().split())
an = [[q + a - z, w + s - x], [q + z - a, w + x - s], [a + z - q, s + x - w], [a + q - z, s + w - x], [z + q - a, x + w - s], [z + a - q, x + s - w]]
zb = [[q, w], [a, s], [z, x]]
i = 0
while i < len(an):
	if (an[i] in an[i + 1:]) | (an[i] in zb):
		del an[i]
	else:
		i += 1
print(len(an))
for i in an:
	print(i[0], i[1])


def check(x, y, xnew, ynew):
	px = list(x)
	py = list(y)
	px.append(xnew)
	py.append(ynew)
	seq = [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]]
	for s in seq:
		a = s[0]
		b = s[1]
		c = s[2]
		l1 = [px[a] - px[b], py[a] - py[b]]
		l2 = [px[b] - px[c], py[b] - py[c]]
		v = l1[0] * l2[1] - l1[1] * l2[0]
		if v == 0:
			return False
	return True
x = []
y = []
for i in range(3):
	[a, b] = list(map(int, input().split()))
	x.append(a)
	y.append(b)
dx = []
dy = []
for i in range(3):
	a = i
	b = (i + 1) % 3
	dx.append(x[a] - x[b])
	dy.append(y[a] - y[b])
res = set()
for i in range(3):
	for j in range(3):
		for k in range(-1, 2, 2):
			xnew = x[i] + k * dx[j]
			ynew = y[i] + k * dy[j]
			if check(x, y, xnew, ynew):
				res.add((xnew, ynew))
print(len(res))
for e in res:
	print(' '.join(map(str, e)))


xy = [list(map(int, input().split())) for _ in range(3)]
ans = []
for i1 in range(3):
	i2 = (i1 + 1) % 3
	i3 = (i1 + 2) % 3
	xm = xy[i1][0] + xy[i2][0]
	ym = xy[i1][1] + xy[i2][1]
	xt = xm - xy[i3][0]
	yt = ym - xy[i3][1]
	ans.append([xt, yt])
print(len(ans))
for uv in ans:
	print(*uv)


(a, b) = map(int, input().split())
(c, d) = map(int, input().split())
(e, f) = map(int, input().split())
(x1, y1) = (c + e - a, d + f - b)
(x2, y2) = (e + a - c, b + f - d)
(x3, y3) = (a + c - e, b + d - f)
print(3)
print(x1, y1)
print(x2, y2)
print(x3, y3)


import math

def getPoint(a, b, c):
	dx = a[0] - (b[0] - c[0])
	dy = c[1] - (b[1] - a[1])
	return (dx, dy)

def printTupla(a):
	print('{0} {1}'.format(a[0], a[1]))
(ax, ay) = [int(x) for x in input().split()]
(bx, by) = [int(x) for x in input().split()]
(cx, cy) = [int(x) for x in input().split()]
a = (ax, ay)
b = (bx, by)
c = (cx, cy)
total = []
total.append(getPoint(a, b, c))
total.append(getPoint(a, c, b))
total.append(getPoint(b, a, c))
total.append(getPoint(b, c, a))
total.append(getPoint(c, a, b))
total.append(getPoint(c, b, a))
total = set(total)
print(len(total))
for x in total:
	printTupla(x)


parallelogram = []
for i in range(3):
	(x, y) = map(int, input().split())
	parallelogram.append([x, y])
print(3)
mid1x = parallelogram[1][0] + parallelogram[2][0] - parallelogram[0][0]
mid1y = parallelogram[1][1] + parallelogram[2][1] - parallelogram[0][1]
mid2x = parallelogram[1][0] + parallelogram[0][0] - parallelogram[2][0]
mid2y = parallelogram[1][1] + parallelogram[0][1] - parallelogram[2][1]
print(mid2x, mid2y)
mid3x = parallelogram[2][0] + parallelogram[0][0] - parallelogram[1][0]
mid3y = parallelogram[2][1] + parallelogram[0][1] - parallelogram[1][1]
print(mid3x, mid3y)
print(mid1x, mid1y)


(a1, a2) = [int(i) for i in input().split()]
(b1, b2) = [int(i) for i in input().split()]
(c1, c2) = [int(i) for i in input().split()]
(x1, x2) = (b1 - a1, b2 - a2)
(y1, y2) = (c1 - b1, c2 - b2)
(z1, z2) = (a1 - c1, a2 - c2)
print(3)
print(a1 + y1, a2 + y2)
print(a1 - y1, a2 - y2)
print(a1 + x1 - z1, a2 + x2 - z2)


(x, y) = map(int, input().split())
(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
print(3)
print(str(x + x1 - x2) + ' ' + str(y + y1 - y2))
print(str(x - x1 + x2) + ' ' + str(y - y1 + y2))
print(str(x1 - x + x2) + ' ' + str(y1 - y + y2))


A = [float(i) for i in input().split()]
B = [float(i) for i in input().split()]
C = [float(i) for i in input().split()]
cAB = [(A[0] + B[0]) / 2, (A[1] + B[1]) / 2]
cAC = [(A[0] + C[0]) / 2, (A[1] + C[1]) / 2]
cBC = [(C[0] + B[0]) / 2, (C[1] + B[1]) / 2]
p1 = [2 * cAB[0] - C[0], 2 * cAB[1] - C[1]]
p2 = [2 * cAC[0] - B[0], 2 * cAC[1] - B[1]]
p3 = [2 * cBC[0] - A[0], 2 * cBC[1] - A[1]]
print(3)
print(int(p1[0]), int(p1[1]))
print(int(p2[0]), int(p2[1]))
print(int(p3[0]), int(p3[1]))


x = []
y = []
for i in range(3):
	(a, b) = map(int, input().split())
	x.append(a)
	y.append(b)
print(3)
sx = sum(x)
sy = sum(y)
for i in range(3):
	ax = sx - 2 * x[i]
	ay = sy - 2 * y[i]
	print(ax, ay)


(a, b) = list(map(int, input().strip().split()))
(c, d) = list(map(int, input().strip().split()))
(e, f) = list(map(int, input().strip().split()))
print(3)
print(e + c - a, f + d - b)
print(e + a - c, f + b - d)
print(a + c - e, b + d - f)


(i, j) = map(int, input().split())
(k, l) = map(int, input().split())
(m, n) = map(int, input().split())
c = m + k - i
a = k + i - m
e = i + m - k
f = j + n - l
b = l + j - n
d = n + l - j
print('3')
print(a, b)
print(e, f)
print(c, d)


def main():
	l = list((tuple(map(int, input().split())) for _ in '012'))
	print(3)
	for (i, (x, y)) in enumerate(l):
		(a, b) = l[i - 1]
		(u, v) = l[i - 2]
		print(a + u - x, b + v - y)
main()


def f_1(Ax, Ay, Bx, By, Cx, Cy):
	x = Ax + Bx - Ax + Cx - Ax
	y = Ay + By - Ay + Cy - Ay
	return (x, y)

def f_2(Bx, By, Ax, Ay, Cx, Cy):
	x = Bx + Ax - Bx + Cx - Bx
	y = By + Ay - By + Cy - By
	return (x, y)

def f_3(Cx, Cy, Ax, Ay, Bx, By):
	x = Cx + Ax - Cx + Bx - Cx
	y = Cy + Ay - Cy + By - Cy
	return (x, y)
(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
(x, y) = f_1(x1, y1, x2, y2, x3, y3)
(xx, yy) = f_2(x2, y2, x1, y1, x3, y3)
(xxx, yyy) = f_3(x3, y3, x1, y1, x2, y2)
print(3)
print(x, y)
print(xx, yy)
print(xxx, yyy)


(ax, ay) = map(int, input().split())
(bx, by) = map(int, input().split())
(cx, cy) = map(int, input().split())
if abs(ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)) < 1e-07:
	print(0)
	exit()
pos = set()

def t(p1, p2, px):
	return (p2[0] - p1[0] + px[0], p2[1] - p1[1] + px[1])
pos.add(t((ax, ay), (bx, by), (cx, cy)))
pos.add(t((bx, by), (ax, ay), (cx, cy)))
pos.add(t((ax, ay), (cx, cy), (bx, by)))
pos.add(t((cx, cy), (ax, ay), (bx, by)))
pos.add(t((bx, by), (cx, cy), (ax, ay)))
pos.add(t((cx, cy), (bx, by), (ax, ay)))
print(len(pos))
for i in pos:
	print(i[0], i[1])


def read(t=int):
	return t(input())

def read_arr(t=int):
	return [t(i) for i in str(input()).split()]
t = 1
for i in range(t):
	(x1, y1) = read_arr()
	(x2, y2) = read_arr()
	(x3, y3) = read_arr()
	print(3)
	print(x1 + x2 - x3, y1 + y2 - y3)
	print(x2 + x3 - x1, y2 + y3 - y1)
	print(x3 + x1 - x2, y3 + y1 - y2)


x = [[0, 0], [0, 0], [0, 0]]
(x[0][0], x[0][1]) = map(int, input().split())
(x[1][0], x[1][1]) = map(int, input().split())
(x[2][0], x[2][1]) = map(int, input().split())
print(3)
print(x[2][0] + x[1][0] - x[0][0], x[2][1] + x[1][1] - x[0][1])
print(x[2][0] - x[1][0] + x[0][0], x[2][1] - x[1][1] + x[0][1])
print(x[1][0] - x[2][0] + x[0][0], x[1][1] - x[2][1] + x[0][1])


def Maia():
	sx = set()
	sy = set()
	Ax = []
	Ay = []
	(x1, y1) = map(int, input().split())
	Ax.append(x1)
	Ay.append(y1)
	(x2, y2) = map(int, input().split())
	Ax.append(x2)
	Ay.append(y2)
	(x3, y3) = map(int, input().split())
	Ax.append(x3)
	Ay.append(y3)
	print(3)
	for i in range(3):
		X = Ax[0] + Ax[1] + Ax[2] - 2 * Ax[i]
		Y = Ay[0] + Ay[1] + Ay[2] - 2 * Ay[i]
		print(X, Y)
Maia()


def fourth_side(p1, p2, p3):
	m = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2]
	print(int(2 * m[0] - p3[0]), int(2 * m[1] - p3[1]))
arr = []
for i in range(3):
	arr.append(list(map(int, input().split())))
print(3)
for i in range(3):
	fourth_side(arr[i % 3], arr[(i + 1) % 3], arr[(i + 2) % 3])


def main():
	points = [None] * 3
	for i in range(3):
		point = [int(x) for x in input().split()]
		points[i] = point
	lastPoints = solver(points)
	print(len(lastPoints))
	for point in lastPoints:
		print(point[0], point[1])

def solver(points):
	point1 = lastPoint(points)
	point2 = lastPoint(points[1:] + [points[0]])
	point3 = lastPoint([points[2]] + points[0:2])
	return [point1, point2, point3]

def lastPoint(points):
	(x0, y0) = points[0]
	(x1, y1) = points[1]
	(x2, y2) = points[2]
	return (x0 + x2 - x1, y0 + y2 - y1)
main()


one = list((int(x) for x in input().split()))
two = list((int(x) for x in input().split()))
three = list((int(x) for x in input().split()))
answer = set()
onetwodx = one[0] - two[0]
onetwody = one[1] - two[1]
answer.add((three[0] + onetwodx, three[1] + onetwody))
answer.add((three[0] - onetwodx, three[1] - onetwody))
onethreedx = one[0] - three[0]
onethreedy = one[1] - three[1]
answer.add((two[0] + onethreedx, two[1] + onethreedy))
answer.add((two[0] - onethreedx, two[1] - onethreedy))
twothreedx = two[0] - three[0]
twothreedy = two[1] - three[1]
answer.add((one[0] + twothreedx, one[1] + twothreedy))
answer.add((one[0] - twothreedx, one[1] - twothreedy))
print(3)
for x in answer:
	print(str(x[0]) + ' ' + str(x[1]))


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
q1 = complex(x2 - x1, y2 - y1) + complex(x3 - x1, y3 - y1)
q2 = complex(x1 - x2, y1 - y2) + complex(x3 - x2, y3 - y2)
q3 = complex(x1 - x3, y1 - y3) + complex(x2 - x3, y2 - y3)
print('3')
print(int(x1 + q1.real), int(y1 + q1.imag))
print(int(x2 + q2.real), int(y2 + q2.imag))
print(int(x3 + q3.real), int(y3 + q3.imag))


from sys import stdin
(x1, y1) = map(int, stdin.readline().split())
(x2, y2) = map(int, stdin.readline().split())
(x3, y3) = map(int, stdin.readline().split())
facteurs = [[1, 1, -1], [1, -1, 1], [-1, 1, 1]]
points = [(x1, y1), (x2, y2), (x3, y3)]
solution = []
nbSolution = 0
for (fact1, fact2, fact3) in facteurs:
	(xSol, ySol) = (x1 * fact1 + x2 * fact2 + x3 * fact3, y1 * fact1 + y2 * fact2 + y3 * fact3)
	if (xSol, ySol) not in solution and (xSol, ySol) not in points:
		nbSolution += 1
		solution.append((xSol, ySol))
print(nbSolution)
for i in range(nbSolution):
	print(*solution[i])


import math
EPSILON = 10 ** (-3)

class Vector:

	def __init__(self, d=2, coords=[0, 0]):
		self.d = d
		self.coords = coords[:]

	@staticmethod
	def fromEnds(p1, p2):
		n = len(p1)
		assert n == len(p2)
		v = []
		for i in range(n):
			v.append(p2[i] - p1[i])
		return Vector(n, v)

	def apply(self, point):
		return tuple([self.coords[i] + point[i] for i in range(self.d)])

	def inverse(self):
		return Vector(self.d, list(map(lambda x: -x, self.coords)))

	def __repr__(self):
		return 'Vector[{}] ({})'.format(self.d, self.coords)

	def len(self):
		return math.sqrt(sum((x * x for x in self.coords)))

	def __add__(self, other):
		assert self.d == other.d
		return Vector(self.d, [self.coords[i] + other.coords[i] for i in range(self.d)])

	def __eq__(self, other):
		return self.d == other.d and self.coords == other.coords

	def extend(self, k):
		return Vector(self.d, [x * k for x in self.coords])

	def scalmul(self, other):
		assert self.d == other.d
		return sum((self.coords[i] * other.coords[i] for i in range(self.d)))

	def cos(self, other):
		return self.scalmul(other) / (self.len() * other.len())

	def is_ort(self, other):
		return self.scalmul(other) <= EPSILON

	def proj_to(self, other):
		return self.scalmul(other) / other.len()

	def proj_from(self, other):
		return other.proj_to(self)
t = lambda : tuple(map(int, input().split()))
(p1, p2, p3) = (t(), t(), t())
p = [p1, p2, p3]
ans = set()
for i in range(3):
	others = []
	for _p in p:
		if _p != p[i]:
			others.append(_p)
	assert len(others) == 2
	v1 = Vector.fromEnds(others[0], others[1])
	v2 = Vector.fromEnds(others[1], others[0])
	ans.add(v1.apply(p[i]))
	ans.add(v2.apply(p[i]))
print(len(ans))
for item in ans:
	print(' '.join(map(str, item)))


p = [list(map(int, input().split())) for i in range(3)]
v = set()
for i in range(3):
	(j, k) = ((i + 1) % 3, (i + 2) % 3)
	(dx, dy) = (p[j][0] - p[k][0], p[j][1] - p[k][1])
	v.add((p[i][0] + dx, p[i][1] + dy))
	v.add((p[i][0] - dx, p[i][1] - dy))
print(len(v))
for vi in v:
	print(vi[0], vi[1])


(ax, ay) = map(int, input().split())
(bx, by) = map(int, input().split())
(cx, cy) = map(int, input().split())
d1x = bx + cx - ax
d1y = by + cy - ay
d2x = cx + ax - bx
d2y = cy + ay - by
d3x = ax + bx - cx
d3y = ay + by - cy
print('3')
print(d1x, d1y)
print(d2x, d2y)
print(d3x, d3y)


pl = [list(map(int, input().split())) for _ in range(3)]
xl = [p[0] for p in pl]
yl = [p[1] for p in pl]
s4 = set([(sum(xl) - (xl[i] << 1), sum(yl) - (yl[i] << 1)) for i in range(3)])
print(len(s4))
[print(*s) for s in s4]


def Inter(*List):
	length = len(List)
	for l in range(length):
		indexx = 0
		for i in List[l]:
			List[l][indexx] = int(i)
			indexx += 1

def Point(a, b, p):
	x = a[0] - b[0]
	y = a[1] - b[1]
	return [p[0] + x, p[1] + y]
while True:
	try:
		a = input().split()
		b = input().split()
		c = input().split()
		Inter(a, b, c)
		print(3)
		x1 = Point(a, b, c)
		x2 = Point(b, c, a)
		x3 = Point(c, a, b)
		print(x1[0], x1[1])
		print(x2[0], x2[1])
		print(x3[0], x3[1])
	except EOFError:
		break


(AX, AY) = (int(x) for x in input().split(' '))
(BX, BY) = [int(x) for x in input().split(' ')]
(CX, CY) = [int(x) for x in input().split(' ')]
print(3)
print(str(AX + BX - CX) + ' ' + str(AY + BY - CY))
print(str(AX - BX + CX) + ' ' + str(AY - BY + CY))
print(str(BX - AX + CX) + ' ' + str(BY - AY + CY))


(x1, y1) = list(map(int, input().split()))
(x2, y2) = list(map(int, input().split()))
(x3, y3) = list(map(int, input().split()))
a = set()
a.add((x1 + x2 - x3, y1 + y2 - y3))
a.add((x1 + x3 - x2, y1 + y3 - y2))
a.add((x2 + x3 - x1, y2 + y3 - y1))
print(len(a))
for i in a:
	print(*i)


liste = [[] for i in range(3)]
for i in range(3):
	liste[i] = [int(element) for element in input().split(' ')]
res = [str(3)]
new_point_x = liste[0][0] + (liste[2][0] - liste[1][0])
new_point_y = liste[0][1] + (liste[2][1] - liste[1][1])
res.append(str(new_point_x) + ' ' + str(new_point_y))
new_point_x = liste[2][0] - (liste[0][0] - liste[1][0])
new_point_y = liste[2][1] - (liste[0][1] - liste[1][1])
res.append(str(new_point_x) + ' ' + str(new_point_y))
new_point_x = liste[1][0] - (liste[2][0] - liste[0][0])
new_point_y = liste[1][1] - (liste[2][1] - liste[0][1])
res.append(str(new_point_x) + ' ' + str(new_point_y))
print('\n'.join(res))


lis = []
for i in range(3):
	(a, b) = map(int, input().split())
	lis.append([a, b])
a = (lis[2][0] + lis[1][0] - lis[0][0], lis[2][1] + lis[1][1] - lis[0][1])
b = (lis[2][0] - lis[1][0] + lis[0][0], lis[2][1] - lis[1][1] + lis[0][1])
c = (lis[0][0] + lis[1][0] - lis[2][0], lis[0][1] - lis[2][1] + lis[1][1])
print(3)
print(*a)
print(*b)
print(*c)


l = []
m = []
v = []
h = []
for i in range(3):
	(x, y) = map(int, input().split())
	l.append(x)
	m.append(y)
print(3)
v.append(l[0] - l[-1] + l[1])
h.append(m[0] - m[-1] + m[1])
v.append(l[-1] - l[1] + l[0])
h.append(m[-1] - m[1] + m[0])
v.append(l[1] - l[0] + l[-1])
h.append(m[1] - m[0] + m[-1])
for i in range(3):
	print(v[i], ' ', h[i])


(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
print(3)
o = [[(x1 + x2) / 2, (y1 + y2) / 2], [(x3 + x2) / 2, (y3 + y2) / 2], [(x1 + x3) / 2, (y1 + y3) / 2]]
print(int(o[1][0] * 2 - x1), int(o[1][1] * 2 - y1))
print(int(o[0][0] * 2 - x3), int(o[0][1] * 2 - y3))
print(int(o[2][0] * 2 - x2), int(o[2][1] * 2 - y2))


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())

def dist(x, y, c, d):
	return mt.sqrt((x - c) ** 2 + (y - d) ** 2)

def circle(x1, y1, x2, y2, r1, r2):
	distSq = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
	if distSq + r2 <= r1:
		return True
	else:
		return False
d = []
for i in range(3):
	(a, b) = M()
	d.append([a, b])
f = set([])
for i in range(2):
	for j in range(i + 1, 3):
		f.add((d[i][0] + d[j][0] - d[3 - i - j][0], d[i][1] + d[j][1] - d[3 - i - j][1]))
print(len(f))
for i in f:
	print(*i)


v = []
for i in range(3):
	k = list(map(int, input().split()))
	v.append((k[0], k[1]))
m = []
fv = []
from itertools import combinations as ncr
vcr = list(ncr(v, 2))
for i in range(len(vcr)):
	v1 = vcr[i]
	p1 = v1[0]
	p2 = v1[1]
	p3 = list(set(v) - set(v1))[0]
	mid = ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
	m.append(mid)
	fv0 = 2 * mid[0] - p3[0]
	fv1 = 2 * mid[1] - p3[1]
	if fv0 != 0 and fv1 != 0:
		if fv0 % int(fv0) == 0 and fv1 % int(fv1) == 0:
			fv.append((fv0, fv1))
	if fv0 == 0 and fv1 % int(fv1) == 0 or (fv0 % int(fv0) == 0 and fv1 == 0):
		fv.append((fv0, fv1))
print(len(set(fv)))
for p in set(fv):
	print(str(int(p[0])) + ' ' + str(int(p[1])))


A = set()
(x1, y1) = map(int, input().split())
(x2, y2) = map(int, input().split())
(x3, y3) = map(int, input().split())
A.add((x1, y1))
A.add((x2, y2))
A.add((x3, y3))
(x, y) = (x1 - x2, y1 - y2)
A.add((x3 + x, y3 + y))
A.add((x3 - x, y3 - y))
(x, y) = (x2 - x3, y2 - y3)
A.add((x1 + x, y1 + y))
A.add((x1 - x, y1 - y))
(x, y) = (x1 - x3, y1 - y3)
A.add((x2 + x, y2 + y))
A.add((x2 - x, y2 - y))
A.remove((x1, y1))
A.remove((x2, y2))
A.remove((x3, y3))
print(len(A))
for (x, y) in A:
	print(str(x) + ' ' + str(y))


(mx1, my1) = map(int, input().split())
(mx2, my2) = map(int, input().split())
(mx3, my3) = map(int, input().split())
print(3)
print(mx1 + mx2 - mx3, my1 + my2 - my3)
print(mx1 + mx3 - mx2, my1 + my3 - my2)
print(mx2 + mx3 - mx1, my2 + my3 - my1)


import math, sys, re, itertools, pprint, collections, copy
(rs, ri, rai, raf) = (input, lambda : int(input()), lambda : list(map(int, input().split())), lambda : list(map(float, input().split())))
a = rai()
b = rai()
c = rai()
bc = [c[0] - b[0], c[1] - b[1]]
ba = [a[0] - b[0], a[1] - b[1]]
ac = [c[0] - a[0], c[1] - a[1]]
sum2 = lambda a, b: tuple([a[0] + b[0], a[1] + b[1]])
inv = lambda a: [-a[0], -a[1]]
res = set()
res.add(sum2(a, bc))
res.add(sum2(a, inv(bc)))
res.add(sum2(b, ac))
res.add(sum2(b, inv(ac)))
res.add(sum2(c, ba))
res.add(sum2(c, inv(ba)))
print(len(res))
for (x, y) in res:
	print(x, y)


class Cord(object):

	def __init__(self, x, y):
		self.x = x
		self.y = y

	def print(self):
		print('{0} {1}'.format(self.x, self.y))

	def __str__(self):
		return '{0} {1}'.format(self.x, self.y)

def get_point(a, b, c):
	x = a.x - b.x + c.x
	y = c.y - b.y + a.y
	return Cord(x, y)

def main():
	cords = [Cord(0, 0) for i in range(0, 3)]
	res = [0 for i in range(0, 6)]
	for i in range(0, 3):
		(x, y) = map(int, input().split())
		cords[i].x = x
		cords[i].y = y
	res[0] = get_point(cords[0], cords[1], cords[2])
	res[1] = get_point(cords[0], cords[2], cords[1])
	res[2] = get_point(cords[1], cords[2], cords[0])
	res[3] = get_point(cords[1], cords[0], cords[2])
	res[4] = get_point(cords[2], cords[1], cords[0])
	res[5] = get_point(cords[2], cords[0], cords[1])
	final = []
	for i in res:
		if len(final) == 0:
			final.append(i)
		else:
			flag = False
			for j in final:
				if i.x == j.x and i.y == j.y:
					flag = True
					break
			if not flag:
				final.append(i)
	print(len(final))
	for i in final:
		i.print()
main()


(a1, a2) = map(int, input().split())
(b1, b2) = map(int, input().split())
(c1, c2) = map(int, input().split())
d1 = a1 + b1 - c1
d2 = a2 + b2 - c2
d = str(d1) + ' ' + str(d2)
l = [d]
d1 = a1 - b1 + c1
d2 = a2 - b2 + c2
d = str(d1) + ' ' + str(d2)
if d not in l:
	l.append(d)
d1 = -a1 + b1 + c1
d2 = -a2 + b2 + c2
d = str(d1) + ' ' + str(d2)
if d not in l:
	l.append(d)
print(len(l))
for x in l:
	print(x)


(x1, y1) = tuple(map(int, str(input()).split()))
(x2, y2) = tuple(map(int, str(input()).split()))
(x3, y3) = tuple(map(int, str(input()).split()))
a = (x1 + (x3 - x2), y1 + (y3 - y2))
b = (x2 + (x1 - x3), y2 + (y1 - y3))
c = (x3 + (x2 - x1), y3 + (y2 - y1))
print(3)
print(a[0], a[1])
print(b[0], b[1])
print(c[0], c[1])


(a1, a2) = map(int, input().split())
(b1, b2) = map(int, input().split())
(c1, c2) = map(int, input().split())
l = set()
n1 = a1 - (c1 - b1)
n2 = a2 - (c2 - b2)
l.add((n1, n2))
n1 = a1 + (c1 - b1)
n2 = a2 + (c2 - b2)
l.add((n1, n2))
n1 = c1 + (a1 - b1)
n2 = c2 + (a2 - b2)
l.add((n1, n2))
n1 = c1 - (a1 - b1)
n2 = c2 - (a2 - b2)
l.add((n1, n2))
n1 = b1 - (a1 - c1)
n2 = b2 - (a2 - c2)
l.add((n1, n2))
n1 = b1 + (a1 - c1)
n2 = b2 + (a2 - c2)
l.add((n1, n2))
print(len(l))
for i in list(l):
	print(i[0], i[1])


a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
print(3)
print(a[0] + b[0] - c[0], a[1] + b[1] - c[1])
print(b[0] + c[0] - a[0], b[1] + c[1] - a[1])
print(c[0] + a[0] - b[0], c[1] + a[1] - b[1])


import sys
import math
import itertools
import collections

def getdict(n):
	d = {}
	if type(n) is list or type(n) is str:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

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

def wr(arr):
	return '\n'.join(map(str, arr))

def revn(n):
	return int(str(n)[::-1])

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True
p = []
for i in range(3):
	p.append(li())
sx = sy = 0
for i in range(3):
	sx += p[i][0]
	sy += p[i][1]
print(3)
for i in range(3):
	print(sx - 2 * p[i][0], sy - 2 * p[i][1])


l = []
for i in range(3):
	(x, y) = list(map(int, input().split()))
	l.append([x, y])
S = set()

def calc(a):
	ans = 0
	n = len(a)
	for i in range(n):
		ans += a[i][0] * a[(i + 1) % n][1] - a[i][1] * a[(i + 1) % n][0]
	return ans
for i in range(3):
	for j in range(3):
		if i == j:
			continue
		for k in range(3):
			if i == k or i == j:
				continue
			x = l[i][0] + l[j][0] - l[k][0]
			y = l[i][1] + l[j][1] - l[k][1]
			new = []
			new.append(l[i])
			new.append(l[k])
			new.append(l[j])
			new.append([x, y])
			if calc(new) > 0:
				S.add(tuple([x, y]))
print(len(S))
for i in S:
	print(i[0], i[1])


(x, y) = map(int, input().split())
(z, w) = map(int, input().split())
(u, v) = map(int, input().split())
print('3')
print(x - z + u, y - w + v)
print(x - u + z, y - v + w)
print(z - x + u, w - y + v)


points = []
results = []
for i in range(3):
	(x, y) = [int(x) for x in input().split()]
	points.append((x, y))
point = (points[2][0] + (points[0][0] - points[1][0]), points[2][1] + (points[0][1] - points[1][1]))
if point not in results:
	results.append(point)
point2 = (points[2][0] + (-points[0][0] + points[1][0]), points[2][1] + (-points[0][1] + points[1][1]))
if point2 not in results:
	results.append(point2)
point3 = (points[1][0] + (points[0][0] - points[2][0]), points[1][1] + (points[0][1] - points[2][1]))
if point3 not in results:
	results.append(point3)
point4 = results.append((points[1][0] + (-points[0][0] + points[2][0]), points[1][1] + (-points[0][1] + points[2][1])))
if point4 not in results:
	results.append(point4)
point5 = results.append((points[0][0] - (points[2][0] - points[1][0]), points[0][1] + (points[2][1] - points[1][1])))
if point5 not in results:
	results.append(point5)
point6 = results.append((points[0][0] - (-points[2][0] + points[1][0]), points[0][1] + (-points[2][1] + points[1][1])))
if point6 not in results:
	results.append(point6)
print(3)
print(str(results[0][0]) + ' ' + str(results[0][1]))
print(str(results[1][0]) + ' ' + str(results[1][1]))
print(str(results[2][0]) + ' ' + str(results[2][1]))


(p1, p2) = list(map(int, input().split()))
(q1, q2) = list(map(int, input().split()))
(r1, r2) = list(map(int, input().split()))
(a1, a2) = (p1 + q1 - r1, p2 + q2 - r2)
(b1, b2) = (q1 + r1 - p1, q2 + r2 - p2)
(c1, c2) = (p1 + r1 - q1, p2 + r2 - q2)
print(3)
print(a1, a2)
print(b1, b2)
print(c1, c2)


import math

class Point:

	def __init__(self, first_arg=0, second_arg=0):
		if type(first_arg) == str:
			(self.x, self.y) = map(float, first_arg.split())
		else:
			self.x = first_arg
			self.y = second_arg

	def dist(self):
		return math.hypot(self.x, self.y)

	def __str__(self):
		return str(int(self.x)) + ' ' + str(int(self.y))

	def __add__(self, other):
		return Point(self.x + other.x, self.y + other.y)

class Vector:

	def __init__(self, first_arg=0, second_arg=0):
		if type(first_arg) == str:
			(self.x, self.y) = map(float, first_arg.split())
		elif type(first_arg) == Point:
			self.x = second_arg.x - first_arg.x
			self.y = second_arg.y - first_arg.y
		else:
			self.x = first_arg
			self.y = second_arg

	def dist(self):
		return math.hypot(self.x, self.y)

	def __str__(self):
		return str(self.x) + ' ' + str(self.y)

	def __mod__(self, other):
		return self.x * other.y - self.y * other.x

	def __mul__(self, other):
		return self.x * other.y + self.y * other.y
A = Point(input())
B = Point(input())
C = Point(input())
(AB, AC, BA, BC, CA, CB) = (Vector(A, B), Vector(A, C), Vector(B, A), Vector(B, C), Vector(C, A), Vector(C, B))
print(3)
print(A + AB + AC)
print(B + BA + BC)
print(C + CA + CB)


A = [int(x) for x in input().split(' ')]
B = [int(x) for x in input().split(' ')]
C = [int(x) for x in input().split(' ')]

def searchD(a, b, c):
	(Ax, Ay, Bx, By, Cx, Cy) = (a[0], a[1], b[0], b[1], c[0], c[1])
	Dx = Bx + Cx - Ax
	Dy = By + Cy - Ay
	return (Dx, Dy)
D1 = searchD(A, B, C)
(A, B, C) = (B, C, A)
D2 = searchD(A, B, C)
(A, B, C) = (B, C, A)
D3 = searchD(A, B, C)
arr = [D1, D2, D3]
print(3)
for point in arr:
	print('%d %d' % (point[0], point[1]))


(a, b) = map(int, input().split())
(c, d) = map(int, input().split())
(e, f) = map(int, input().split())
res = set()
res.add((e + c - a, f + d - b))
res.add((e - c + a, f - d + b))
res.add((c + e - a, d + f - b))
res.add((c - e + a, d - f + b))
res.add((a - c + e, b - d + f))
res.add((a + c - e, b + d - f))
print(len(res))
for elem in res:
	print(elem[0], elem[1])


num = input().split()
x1 = int(num[0])
y1 = int(num[1])
num = input().split()
x2 = int(num[0])
y2 = int(num[1])
num = input().split()
x3 = int(num[0])
y3 = int(num[1])
a = []
a.append([x3 + x1 - x2, y3 + y1 - y2])
a.append([x3 + x2 - x1, y3 + y2 - y1])
a.append([x2 + x1 - x3, y2 + y1 - y3])
a.append([x2 + x3 - x1, y2 + y3 - y1])
a.append([x1 + x3 - x2, y1 + y3 - y2])
a.append([x1 + x2 - x3, y1 + y2 - y3])
ans = []
for i in range(0, len(a)):
	flag = 1
	for j in range(i + 1, len(a)):
		if j < len(a):
			if a[i][0] == a[j][0] and a[i][1] == a[j][1]:
				flag = 0
				break
	if flag == 1:
		ans.append(a[i])
print(len(ans))
for tmp in ans:
	print(tmp[0], tmp[1])


import math

def get_n():
	return int(input())

def get_int_vector():
	return [int(x) for x in input().split()]

def list2string(list):
	result = []
	for i in list:
		result.append(str(i))
	return ':'.join(result)

def string2vector(string):
	return [int(x) for x in string.split(':')]
points = []
points.append(get_int_vector())
points.append(get_int_vector())
points.append(get_int_vector())
points.sort(key=lambda x: x[1])
points.sort(key=lambda x: x[0])

def get_d(a, b, c):
	result = []
	for i in range(2):
		result.append(a[i] + (b[i] - a[i]) + (c[i] - a[i]))
	return result
result = []
result.append(get_d(points[0], points[1], points[2]))
result.append(get_d(points[1], points[2], points[0]))
result.append(get_d(points[2], points[0], points[1]))
print(3)
for point in result:
	print(point[0], point[1])