You have a two-dimensional list in the following format:

```python
data = [[2, 5], [3, 4], [8, 7]]
```

Each sub-list contains two items, and each item in the sub-lists is an integer.

Write a function `process_data()` that processes each sub-list like so:

 * `[2, 5]` --> `2 - 5` --> `-3`
 * `[3, 4]` --> `3 - 4` --> `-1`
 * `[8, 7]` --> `8 - 7` --> `1`
 
and then returns the product of all the processed sub-lists: `-3 * -1 * 1` --> `3`.

For input, you can trust that neither the main list nor the sublists will be empty.

Difficulty: EASY
Starter code: def process_data(data):
	

Solutions:
def process_data(data):
	r = 1
	for d in data:
		r *= d[0] - d[1]
	return r


from functools import reduce
from itertools import starmap
from operator import mul, sub

def process_data(data):
	return reduce(mul, starmap(sub, data))


def process_data(data):
	product = 1
	for tuple in data:
		product *= tuple[0] - tuple[1]
	return product


def process_data(data):
	from numpy import prod, sum
	return prod([el1 - el2 for (el1, el2) in data])


def process_data(data):
	result = 1
	for item in data:
		result *= item[0] - item[1]
	return result


process_data = lambda d, reduce=__import__('functools').reduce: reduce(int.__mul__, (x - y for (x, y) in d))


from operator import mul, sub
from functools import reduce

def process_data(data):
	return reduce(mul, [reduce(sub, x) for x in data])


from functools import reduce

def process_data(data):
	return reduce(lambda m, n: m * n, [a - b for (a, b) in data], 1)


def process_data(data):
	output = 1
	for sub_list in data:
		output *= sub_list[0] - sub_list[1]
	return output


def process_data(data):
	array = []
	for n in data:
		array_element = n[0] - n[1]
		array.append(array_element)
	c = 1
	for d in array:
		c *= d
	return c