Problem: Find product of all elements at indexes which are factors of M for all possible sorted subsequences of length M
Given an array arr[] of N distinct integers and a positive integer M, the task is to find the product of all the elements at the indexes which are the factors of M for all the possible sorted subsequences of length M from the given array arr[].
Note: The product may be very large, take modulo to 109 + 7.

Sample Input: arr[] = {4, 7, 5, 9, 3}, M = 4
Sample Output: 808556639
Explanation:
There are five possible sets. They are:
{4, 7, 5, 9}. In the sorted order, this set becomes {4, 5, 7, 9}. In this set, index 1, 2 and 4 divides M completely. Therefore, arr[1] * arr[2] * arr[4] = 4 * 5 * 9 = 180.
Similarly, the remaining four sets along with their products are:
{4, 7, 9, 3} -> 108
{4, 5, 9, 3} -> 108
{4, 7, 5, 3} -> 84
{7, 5, 9, 3} -> 135
The total value = ((180 * 108 * 108 * 84 * 135) % (10^9+7)) = 808556639

Solution (python):
# Python3 program to find the product of
# all the combinations of M elements
# from an array whose index in the
# sorted order divides M completely
m = 4

# Iterative Function to calculate
# (x^y)%p in O(log y)
def power(x, y, p):

    res = 1
    x = x % p

    while (y > 0):

        # If y is odd, multiply x with result
        if (y & 1):
            res = (res * x) % p

        # y must be even now
        y = y >> 1
        x = (x * x) % p
    return res

# Iterative Function to calculate
# (nCr)%p and save in f[n][r]
# C(n, r)%p = [ C(n-1, r-1)%p + 
# C(n-1, r)%p ] % p
# and C(n, 0) = C(n, n) = 1
def nCr(n, p, f):

    for i in range (n):
        for j in range (m + 1):

            # If j>i then C(i, j) = 0
            if (j > i):
                f[i][j] = 0

            # If i is equal to j then 
            # C(i, j) = 1
            elif (j == 0 or j == i):
                f[i][j] = 1

            # C(i, j) = ( C(i-1, j) + 
            # C(i-1, j-1))%p
            else:
                f[i][j] = ((f[i - 1][j] + 
                            f[i - 1][j - 1]) % p)

def operations(arr, n, f):

    p = 1000000007
    nCr(n, p - 1, f)

    arr.sort()

    # Initialize the answer
    ans = 1
    
    for i in range (n):

        # For every element arr[i],
        # x is count of occurrence
        # of arr[i] in different set
        # such that index of arr[i]
        # in those sets divides m completely.
        x = 0

        for j in range (1, m + 1):

            # Finding the count of arr[i]
            # by placing it at the index
            # which divides m completely
            if (m % j == 0):

                # Using fermat's little theorem
                x = ((x + (f[n - i - 1][m - j] * 
                           f[i][j - 1]) % (p - 1)) % 
                                          (p - 1))
       
        # Multiplying with the count
        ans = ((ans * power(arr[i],
                            x, p)) % p)
  
    print (ans)

# Driver code
if __name__ == "__main__":
    arr = [4, 5, 7, 9, 3]
    n = len(arr)
    f = [[0 for x in range (m + 1)]
            for y in range (n + 1)]
    operations(arr, n, f)