Конвертация Python кода в C# (или решение задачи)

# -*- coding: utf-8 -*-
# import numpy  # <можно_использовать_numpy>
 
def main():
    c_int_side_dice: int = 6  # сколько граней у кубика
    c_int_dice_number: int = 1000  # кол-во кубиков
    c_int_number_to_find: int = 2000  # число, вероятность выпадения которого хотим найти
    probability = dice_probability(c_int_dice_number, c_int_number_to_find, c_int_side_dice)
    print(probability)
 
 
# собственно поиск вероятности определённого значения
def dice_probability(int_dice_number: int, int_number_to_find: int, c_int_side_dice: int) -> float:
    if int_number_to_find >= int_dice_number and int_number_to_find <= c_int_side_dice * int_dice_number:
        list_values: list[int] = [i for i in range(int_dice_number, c_int_side_dice * int_dice_number + 1)]
        list_probability = get_probabilities(c_int_side_dice, int_dice_number)
 
        for i in range(len(list_values)):
            if list_values[i] == int_number_to_find:
                float_out: float = list_probability[i]
                break
        return float_out
    else:
        # задаваемое число выходит за рамки реально возможного диапазона значений
        return 0.0
 
 
# возвращает список/массив: вероятности выадения
def get_probabilities(int_side_dice: int, int_pow: int) -> list[float]:
    """
    На примере int_side_dice = 6, int_pow = 5
    {
      1: [1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6],
      2: [1 / 36, 2 / 36, 3 / 36, 4 / 36, 5 / 36, 6 / 36, 5 / 36, 4 / 36, 3 / 36, 2 / 36, 1 / 36],
      4: [1 / 1296, 4 / 1296, 10 / 1296, 20 / 1296, 35 / 1296, 56 / 1296, 80 / 1296, 104 / 1296, 125 / 1296, 140 / 1296, 146 / 1296, 140 / 1296, 125 / 1296, 104 / 1296, 80 / 1296, 56 / 1296, 35 / 1296, 20 / 1296, 10 / 1296, 4 / 1296, 1 / 1296]
      5: [1 / 7776, 5 / 7776, 15 / 7776, 35 / 7776, 70 / 7776, 126 / 7776, 205 / 7776, 305 / 7776, 420 / 7776, 540 / 7776, 651 / 7776, 735 / 7776, 780 / 7776, 780 / 7776, 735 / 7776, 651 / 7776, 540 / 7776, 420 / 7776, 305 / 7776, 205 / 7776, 126 / 7776, 70 / 7776, 35 / 7776, 15 / 7776, 5 / 7776, 1 / 7776]
    }
    """
    dict_interm_probability = {1: [1 / int_side_dice] * int_side_dice}
    if int_pow == 0:
        print("Не поддерживается")
        quit()
    elif int_pow != 1:
        list_to_do = map_todo(int_pow) 
        for elem in list_to_do:
            dict_interm_probability[elem[2]] = multiply_cins_orig(dict_interm_probability[elem[0]], dict_interm_probability[elem[1]])
            # dict_interm_probability[elem[2]] = numpy.convolve(dict_interm_probability[elem[0]], dict_interm_probability[elem[1]])  # <можно_использовать_numpy> и не использовать multiply_cins_orig()
    return dict_interm_probability[int_pow]
 
 
# Как добраться до интересующего значения, используя x2/+nx для степеней
def map_todo(int_wanted: int) -> list[tuple[int, int, int]]:
    """
    На примере int_wanted = 5
    Степени "числа":
    1
    1 * 2 = 2 -> tuple(1, 1, 2)
    2 * 2 = 4 -> tuple(2, 2, 4)
    4 + 1 = 5 -> tuple(4, 1, 5)
    """
 
    int_current_id: int = 1
    int_sum: int = 1
    b_ascending: bool = True
    list_solution: list[tuple[int, int, int]] = []
 
    while True:
        if int_sum == int_wanted:
            break
        elif b_ascending and 2 * int_current_id <= int_wanted:
            list_solution.append(  # mult_1, mult_2, result
                (int_current_id, int_current_id, 2 * int_current_id)
            )
            int_current_id = 2 * int_current_id
            int_sum = int_current_id
        elif b_ascending and 2 * int_current_id > int_wanted:
            b_ascending = False
            int_sum = int_current_id
            int_current_id = int(int_current_id / 2)  # чтобы возвращал именно integer
        elif not b_ascending and int_sum + int_current_id <= int_wanted:
            list_solution.append(  # mult_1, mult_2, result
                (int_sum, int_current_id, int_sum + int_current_id)
            )
            int_sum = int_sum + int_current_id
            int_current_id = int(int_current_id / 2)  # чтобы возвращал именно integer
        elif not b_ascending and int_sum + int_current_id > int_wanted:
            int_current_id = int(int_current_id / 2)  # чтобы возвращал именно integer
    return list_solution
 
 
# "умножение" в столбик двух массивов/списков
def multiply_cins_orig(list_in_1: list[int], list_in_2: list[int]) -> list[int]:
    int_len_2: int = len(list_in_2)
    list_dummy: list[list[int]] = []
    for i in range(int_len_2):
        list_dummy.append([0] * i)  # [], [0], [0, 0], [0, 0, 0] ...
 
    list_for_sum: list[list[int]] = []
    i: int = -1
    for elem_2 in list_in_2:
        i += 1
        list_interm: list[int] = [elem_1 * elem_2 for elem_1 in list_in_1]
        list_for_sum.append(list_dummy[i] + list_interm + list_dummy[int_len_2 - i - 1])
 
    """[list_in_1 X list_in_2[0], 0, 0, 0, 0, 0]
    [0, list_in_1 X list_in_2[1], 0, 0, 0, 0]
    [0, 0, list_in_1 X list_in_2[2], 0, 0, 0]
    [0, 0, 0, list_in_1 X list_in_2[3], 0, 0]
    [0, 0, 0, 0, list_in_1 X list_in_2[4], 0]
    [0, 0, 0, 0, 0, list_in_1 X list_in_2[5]]
    """
 
    list_out: list[int] = []
    for i in range(len(list_for_sum[0])):
        sum_out: int = 0
        for j in range(int_len_2):
            sum_out += list_for_sum[j][i]
        list_out.append(sum_out)
    """
    [1 / 216, 3 / 216, 6 / 216, 10 / 216, 15 / 216, 21 / 216, 25 / 216, 27 / 216, 27 / 216, 25 / 216, 21 / 216, 15 / 216, 10 / 216, 6 / 216, 3 / 216, 1 / 216]
    """
    return list_out
 
 
main()