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

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