Algorithms
Medium
2961
3234
Double Modular Exponentiation
double-modular-exponentiation
"""
You are given a 0-indexed 2D array variables where variables[i] = [ai, bi, ci, mi], and an integer target.
An index i is good if the following formula holds:

0 <= i < variables.length
((aibi % 10)ci) % mi == target

Return an array consisting of good indices in any order.

Example 1:

Input: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Output: [0,2]
Explanation: For each index i in the variables array:
1) For the index 0, variables[0] = [2,3,3,10], (23 % 10)3 % 10 = 2.
2) For the index 1, variables[1] = [3,3,3,1], (33 % 10)3 % 1 = 0.
3) For the index 2, variables[2] = [6,1,1,4], (61 % 10)1 % 4 = 2.
Therefore we return [0,2] as the answer.

Example 2:

Input: variables = [[39,3,1000,1000]], target = 17
Output: []
Explanation: For each index i in the variables array:
1) For the index 0, variables[0] = [39,3,1000,1000], (393 % 10)1000 % 1000 = 1.
Therefore we return [] as the answer.


Constraints:

1 <= variables.length <= 100
variables[i] == [ai, bi, ci, mi]
1 <= ai, bi, ci, mi <= 103
0 <= target <= 103
"""
class Solution:
    def getGoodIndices(self, variables: List[List[int]], target: int) -> List[int]:
        
You are given a 0-indexed 2D array variables where variables[i] = [ai, bi, ci, mi], and an integer target.
An index i is good if the following formula holds:

0 <= i < variables.length
((aibi % 10)ci) % mi == target

Return an array consisting of good indices in any order.

Example 1:

Input: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Output: [0,2]
Explanation: For each index i in the variables array:
1) For the index 0, variables[0] = [2,3,3,10], (23 % 10)3 % 10 = 2.
2) For the index 1, variables[1] = [3,3,3,1], (33 % 10)3 % 1 = 0.
3) For the index 2, variables[2] = [6,1,1,4], (61 % 10)1 % 4 = 2.
Therefore we return [0,2] as the answer.

Example 2:

Input: variables = [[39,3,1000,1000]], target = 17
Output: []
Explanation: For each index i in the variables array:
1) For the index 0, variables[0] = [39,3,1000,1000], (393 % 10)1000 % 1000 = 1.
Therefore we return [] as the answer.


Constraints:

1 <= variables.length <= 100
variables[i] == [ai, bi, ci, mi]
1 <= ai, bi, ci, mi <= 103
0 <= target <= 103


Please complete the code below to solve above prblem:
```python
class Solution:
    def getGoodIndices(self, variables: List[List[int]], target: int) -> List[int]:
        
```

my_solution = Solution()

test_input = { "variables": [[2,3,3,10],[3,3,3,1],[6,1,1,4]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == [0,2]

test_input = { "variables": [[39,3,1000,1000]], "target": 17 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,2,4,2],[3,3,1,3],[2,2,2,4],[4,4,2,3],[2,4,1,3]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[9,2,8,5],[7,8,8,8],[8,9,6,1],[8,6,2,2],[3,6,3,1]], "target": 9 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[2,2,3,2],[1,3,3,2],[3,2,2,3],[3,1,2,3],[1,2,3,1],[2,2,2,2],[2,1,3,1],[3,2,2,2],[2,1,3,1],[3,3,1,3]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,2,3,4,5,6,8]

test_input = { "variables": [[1,3,2,3],[4,2,3,3],[4,1,4,4],[4,2,3,1],[4,2,1,1],[1,2,4,1],[1,1,4,2],[1,4,4,3],[1,2,2,3]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[5,4,1,3],[2,5,5,1],[5,3,4,1]], "target": 5 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[4,7,6,7],[7,6,6,4],[6,8,2,3],[8,3,5,8]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,1,2,3,4,5,6]

test_input = { "variables": [[3,5,1,2],[3,2,5,2],[4,4,3,2],[3,2,5,3],[1,5,1,4]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [0,1,4]

test_input = { "variables": [[1,2,1,1],[2,2,2,2],[1,1,1,2],[1,2,2,2]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,3,5,6],[8,2,9,2],[1,4,6,1],[6,4,7,7]], "target": 8 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,5,4,3],[1,3,3,1],[3,3,5,5],[4,5,5,5],[5,1,4,3],[2,5,3,4]], "target": 7 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[9,7,2,7],[9,1,8,1],[9,3,5,6],[6,1,8,4],[9,6,2,3]], "target": 8 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[10,6,8,7],[3,6,1,8]], "target": 5 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[4,6,5,2],[2,6,4,6],[4,6,3,6],[2,2,6,5],[6,5,5,2]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[5,6,5,1],[4,3,1,6],[5,4,4,2]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == [1]

test_input = { "variables": [[5,1,2,4],[4,5,5,5],[5,9,7,4],[7,9,6,3],[1,8,6,1],[1,1,9,9],[3,7,6,5],[2,6,2,6]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [0,2,3,5]

test_input = { "variables": [[1,3,2,5],[5,4,1,2],[2,2,3,2],[4,2,5,4],[1,5,4,1],[2,2,5,2],[3,3,2,1],[2,5,4,3],[2,1,5,1]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,2,1,3],[1,2,1,1],[2,1,3,2],[2,3,1,3],[3,3,1,1],[2,3,2,1],[2,1,3,3],[1,2,2,2],[3,2,1,3]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [7]

test_input = { "variables": [[3,3,2,2],[3,3,2,2]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,6,7,5],[6,3,1,5],[7,5,5,4],[6,2,2,4],[6,1,1,2],[2,6,5,4]], "target": 8 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[7,8,9,3],[7,8,2,8],[2,4,4,8],[8,8,4,4]], "target": 6 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[6,7,6,6],[1,2,4,8],[6,4,2,4],[3,2,4,5]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[2,3,1,1],[3,2,1,1],[2,1,2,3]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[9,8,10,1],[7,1,3,9],[6,8,9,10],[4,8,8,9]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[4,3,2,2],[3,6,4,6],[1,4,1,4],[5,2,5,1],[8,3,6,3],[8,4,8,3]], "target": 6 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,4,4,2],[4,4,1,2],[1,1,3,2],[3,1,4,3],[2,2,3,4],[2,3,2,4],[3,1,4,4],[1,4,1,4],[3,2,1,4]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [1,3,4,5]

test_input = { "variables": [[2,1,1,1],[2,2,2,2],[1,2,1,2],[1,1,1,1],[1,1,1,1],[2,1,2,2],[1,1,2,1],[2,2,2,2]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,1,3,4,5,6,7]

test_input = { "variables": [[3,1,2,4],[3,3,4,2],[3,4,3,4],[3,3,4,2]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [0,1,2,3]

test_input = { "variables": [[4,10,5,8],[7,7,5,8],[4,8,6,2],[6,3,3,2]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,5,3,6],[3,1,6,3],[6,4,1,5],[3,2,3,5],[1,4,7,5],[6,6,6,2],[7,5,6,3],[1,2,7,1],[1,1,6,3]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == [3]

test_input = { "variables": [[1,4,2,3],[4,3,1,4],[3,3,1,3],[1,4,1,3]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [1]

test_input = { "variables": [[1,4,2,2],[5,5,1,2],[3,4,2,3]], "target": 6 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,5,1,1],[4,8,6,8],[5,1,4,9],[4,3,1,2],[5,9,4,7],[8,7,7,1],[9,3,7,5]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,1,3,5]

test_input = { "variables": [[1,1,1,1],[2,2,2,1],[2,2,2,1],[2,2,2,2],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[5,5,6,5],[4,1,2,2],[6,2,5,3],[1,1,5,5],[3,5,6,5]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,4,1,3],[2,4,4,1],[1,1,3,1],[2,3,3,1]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [1,2,3]

test_input = { "variables": [[1,1,1,1],[1,1,1,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[4,2,1,7],[3,3,7,1],[5,5,8,2],[5,1,3,1]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,5,7,2],[2,10,7,10],[6,8,2,2],[9,4,1,2],[1,7,4,1]], "target": 3 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[5,5,3,5],[4,2,5,9],[4,6,6,1],[4,5,3,6]], "target": 8 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,2,1],[1,1,3,2],[2,3,3,2],[1,2,3,2],[1,1,1,3],[2,2,1,2]], "target": 3 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[4,1,3,5],[4,7,1,6],[7,3,5,4],[2,4,2,7],[6,3,4,7]], "target": 7 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[4,2,3,7],[2,9,6,2],[3,8,9,2],[1,7,7,3],[1,3,8,1],[2,4,5,1],[3,6,3,2],[4,4,6,8]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[8,3,7,1],[7,8,3,2],[4,1,5,3],[6,6,6,3],[2,4,7,5]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,6,6],[1,1,1,2],[3,6,6,1],[4,5,5,6],[3,1,6,6],[3,2,2,1],[6,1,1,2]], "target": 6 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[4,2,2,1],[6,3,2,1],[2,4,3,2],[1,1,6,6],[4,6,2,1],[5,4,2,1],[1,2,6,1],[6,2,4,4]], "target": 6 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[2,2,2,2],[1,2,2,3]], "target": 3 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,1]

test_input = { "variables": [[2,5,8,2],[2,6,1,2],[7,4,8,9],[6,3,1,4],[7,1,6,7],[4,6,2,7],[8,2,2,7],[4,5,3,8],[1,2,6,4]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == [3,6]

test_input = { "variables": [[4,2,4,1],[6,1,2,6],[4,3,3,2]], "target": 8 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[6,4,3,5],[7,4,2,6],[1,4,2,1],[4,5,4,5],[7,2,2,7],[7,5,4,3],[2,7,1,3],[6,7,2,2],[4,7,4,1],[7,3,2,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [0,1,3,5]

test_input = { "variables": [[4,10,5,8],[8,8,9,8],[7,1,5,4],[8,9,2,2],[2,2,8,7],[6,8,10,3],[6,8,4,4],[5,4,10,5],[3,7,8,2]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [8]

test_input = { "variables": [[7,5,4,2],[2,1,3,6],[7,2,2,3],[1,4,7,3]], "target": 3 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[2,3,3,3],[3,2,1,3],[2,2,3,2],[3,1,2,2],[1,2,2,1],[2,3,3,3],[3,1,2,2]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [3,6]

test_input = { "variables": [[10,2,6,2],[8,10,5,7]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0]

test_input = { "variables": [[6,8,3,6],[4,8,3,1],[6,8,6,5],[7,4,7,1],[5,2,1,5],[2,3,5,7],[3,2,6,3],[4,3,7,1]], "target": 6 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[5,5,5,1],[6,1,3,2],[3,1,2,6],[2,6,6,5],[6,1,3,6],[4,2,3,1],[2,5,3,5],[6,6,6,2]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,2],[2,1,1,1],[2,1,1,1],[1,1,1,1],[2,1,2,2],[2,2,2,2],[1,1,1,1],[1,2,2,2],[1,2,1,1]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [1,2,3,4,5,6,8]

test_input = { "variables": [[9,4,4,9],[9,4,2,6],[7,5,1,4],[9,2,2,3],[6,5,1,2],[2,7,2,9],[1,8,1,6],[5,4,9,7],[8,1,7,4]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [0,1,3,5,6]

test_input = { "variables": [[1,3,1,3],[2,1,3,2],[2,2,1,1],[1,2,1,3]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,5,5,1],[4,2,6,3],[3,5,6,6],[5,3,1,1],[5,1,3,4],[6,1,6,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [4]

test_input = { "variables": [[1,2,1,2],[1,2,1,2]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,4,2,4],[5,5,3,5],[3,5,3,4],[2,4,5,5],[5,4,4,5],[2,2,2,3]], "target": 5 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,4,4,4],[5,2,4,4],[1,1,5,3],[3,4,1,2],[3,1,2,3],[4,3,3,3],[3,5,4,1],[2,1,4,5],[3,3,1,3]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [0,1,2,3,5,7,8]

test_input = { "variables": [[1,1,6,1],[3,8,4,7],[8,5,5,9],[4,9,1,3],[9,1,1,9]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,4]

test_input = { "variables": [[2,1,2,2],[2,2,2,1],[2,1,2,2],[1,2,1,1],[2,1,2,2],[2,2,2,2]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[5,7,4,2],[2,8,10,10],[4,4,7,2],[7,4,4,6]], "target": 10 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,1,2,3,4,5,6,7,8,9]

test_input = { "variables": [[9,3,6,3],[9,7,2,5],[2,8,9,9],[4,7,7,4],[2,7,3,9],[8,5,5,3],[7,5,4,3],[9,9,2,9],[9,4,8,8]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[7,5,2,3],[1,7,2,3],[9,1,7,1]], "target": 3 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[2,5,7,3],[2,6,5,1],[4,3,6,5]], "target": 3 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[7,8,1,1],[1,5,4,1],[4,7,8,9],[7,9,2,4],[5,1,4,3],[3,9,4,1],[6,6,1,8],[4,8,5,1],[1,4,5,9]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [3,4,8]

test_input = { "variables": [[5,1,6,1],[3,6,5,2],[4,2,5,4],[2,3,5,2],[2,4,3,1],[3,2,3,6],[6,2,4,6],[6,3,3,2]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,2,3,4,6,7]

test_input = { "variables": [[3,2,5,3],[9,4,2,4],[2,4,7,7],[1,4,9,2],[5,1,5,5],[9,5,6,7],[9,1,4,7]], "target": 5 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,2,2,2],[3,1,3,2],[2,1,2,2],[3,2,3,3],[1,1,2,3],[1,1,3,1]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [2,3,5]

test_input = { "variables": [[1,5,2,1],[3,5,3,2],[1,2,4,1],[1,4,1,4],[4,4,1,3],[4,2,4,5],[2,2,4,1],[2,1,3,3]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,2,7,6],[10,6,5,10],[2,4,10,7],[9,5,8,6],[10,6,3,10],[9,6,5,2],[8,10,1,2],[7,1,8,8],[7,7,4,8],[8,3,8,1]], "target": 4 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[6,6,5,2],[3,5,4,3],[2,4,3,3],[6,3,4,4],[4,1,3,6],[1,6,3,5],[3,3,5,5]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,1,2,3]

test_input = { "variables": [[10,3,8,9],[9,1,5,5],[4,5,10,5],[9,8,3,5],[3,5,4,7],[1,10,2,3],[6,2,4,8],[6,4,3,2],[5,9,9,2]], "target": 8 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[7,7,4,3],[2,10,10,4],[8,1,9,1],[9,7,7,9],[8,9,8,5],[9,8,4,2],[1,9,3,8],[6,8,3,1]], "target": 8 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[9,8,1,4],[5,2,7,4],[5,6,3,4],[9,5,9,8],[2,1,10,10],[10,9,9,2],[8,5,2,3],[10,10,3,8],[1,7,8,1],[1,4,3,5]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[2,3,4,4],[2,3,7,2],[4,2,6,3],[2,3,3,6],[5,1,2,7],[7,6,7,1]], "target": 5 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,3,8,8],[2,5,6,5],[8,1,2,3],[1,4,8,7],[8,5,5,7],[6,6,3,9],[5,6,7,1],[4,7,5,1],[1,5,1,5],[5,3,2,1]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,1,7,8],[4,3,7,8],[7,4,2,2]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [2]

test_input = { "variables": [[4,4,8,8],[4,7,8,7],[1,4,8,2],[5,5,6,4],[7,8,4,3],[8,6,2,1]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == [2,3,4]

test_input = { "variables": [[2,5,2,5],[1,1,4,1],[3,2,4,3],[3,1,3,4]], "target": 1 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[2,2,1,2],[2,2,2,2],[2,2,1,2]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[7,6,4,6],[3,7,2,3],[7,7,1,7],[7,7,6,5],[6,1,1,4],[1,4,2,3],[1,2,4,2],[3,2,2,1],[7,6,2,5],[2,4,5,7]], "target": 7 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[1,1,2,1],[1,1,1,2],[1,1,2,1],[2,1,1,2],[1,1,2,1],[2,1,1,1]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[4,5,8,5],[4,2,9,9],[2,3,3,3],[8,6,3,1]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == [2]

test_input = { "variables": [[4,1,4,2],[3,4,3,4],[5,5,1,5],[5,1,1,4],[4,2,1,5],[5,2,1,1],[1,4,1,4],[1,4,5,5],[5,1,4,5],[1,2,1,2]], "target": 2 }
assert my_solution.getGoodIndices(**test_input) == []

test_input = { "variables": [[3,1,3,3],[1,2,1,2],[3,1,1,3],[2,2,1,1],[3,3,2,2],[2,3,1,1]], "target": 0 }
assert my_solution.getGoodIndices(**test_input) == [0,2,3,5]