






def 				snake_case__							(							UpperCAmelCase							:  List[Any]       ):
    lowerCAmelCase__   :Tuple      							=				1
    lowerCAmelCase__   :Union[str, Any]      							=				2
    while i * i <= n:
        lowerCAmelCase__   :List[str]      							=				0
        while n % i == 0:
            n //= i
            multiplicity += 1
        n_divisors *= multiplicity + 1
        i += 1
    if n > 1:
        n_divisors *= 2
    return n_divisors


def 				snake_case__							(							):
    lowerCAmelCase__   :List[str]      							=				1
    lowerCAmelCase__   :str      							=				1

    while True:
        i += 1
        t_num += i

        if count_divisors(UpperCAmelCase       ) > 5_0_0:
            break

    return t_num


if __name__ == "__main__":
 print(solution())











from __future__ import annotations

import numpy as np


def 				snake_case__							(							UpperCAmelCase							:  np.ndarray       ):
    lowerCAmelCase__							,lowerCAmelCase__   :List[str]      							=				np.shape(UpperCAmelCase       )
    if rows != columns:
        lowerCAmelCase__   :Tuple      							=				(
            "'table' has to be of square shaped array but got a "
            F'''{rows}x{columns} array:\n{table}'''
        )
        raise ValueError(UpperCAmelCase       )

    lowerCAmelCase__   :Optional[Any]      							=				np.zeros((rows, columns)       )
    lowerCAmelCase__   :Tuple      							=				np.zeros((rows, columns)       )
    for i in range(UpperCAmelCase       ):
        for j in range(UpperCAmelCase       ):
            lowerCAmelCase__   :Any      							=				sum(lower[i][k] * upper[k][j] for k in range(UpperCAmelCase       )       )
            if upper[j][j] == 0:
                raise ArithmeticError("No LU decomposition exists"       )
            lowerCAmelCase__   :Any      							=				(table[i][j] - total) / upper[j][j]
        lowerCAmelCase__   :Tuple      							=				1
        for j in range(UpperCAmelCase    ,			UpperCAmelCase       ):
            lowerCAmelCase__   :Optional[Any]      							=				sum(lower[i][k] * upper[k][j] for k in range(UpperCAmelCase       )       )
            lowerCAmelCase__   :Dict      							=				table[i][j] - total
    return lower, upper


if __name__ == "__main__":
 import doctest

 doctest.testmod()



