def number_of_divisible_triplet_sums(numbers, divisor):
    number_of_numbers = len(numbers)
    count_of_divisible_triplets = 0

    for first_index in range(number_of_numbers):
        for second_index in range(first_index + 1, number_of_numbers):
            for third_index in range(second_index + 1, number_of_numbers):
                # Calculate sum of the current triplet
                triplet_sum = numbers[first_index] + numbers[second_index] + numbers[third_index]

                # Check if the sum is divisible by the divisor
                if triplet_sum % divisor == 0:

                    count_of_divisible_triplets += 1
                    # Increment count if triplet sum is divisible

    return count_of_divisible_triplets

def number_of_divisible_triplet_sums(number_array, divisor):    array_length = len(number_array)
    remainder_counts = [0] * divisor

    for number in number_array:
        remainder_counts[number % divisor] += 1

    triplet_count = 0

    #Case 1: (0,0,0)
    triplet_count += remainder_counts[0] * (remainder_counts[0] - 1) * (remainder_counts[0] - 2) // 6

    #Case 2: (a,a,a), where (3 * a) % divisor == 0
    for remainder in range(1, divisor):
        if (3 * remainder) % divisor == 0:
            triplet_count += remainder_counts[remainder] * (remainder_counts[remainder] - 1) * (remainder_counts[remainder] - 2) // 6

    #Case 3: (0, a, divisor-a) 
    for remainder in range(1, divisor // 2 + 1):
        triplet_count += remainder_counts[0] * remainder_counts[remainder] * remainder_counts[divisor - remainder]

    #Case 4: (a, a, divisor - 2a)
    for remainder in range(1, divisor):
        if (2 * remainder) < divisor and (divisor - 2 * remainder) != remainder:
            triplet_count += remainder_counts[remainder] * (remainder_counts[remainder] - 1) // 2 * remainder_counts[divisor - 2 * remainder]

    #Case 5: (a, b, divisor - a - b)
    for remainder_a in range(1, divisor):
        for remainder_b in range(remainder_a + 1, divisor):
            remainder_c = divisor - remainder_a - remainder_b

            if remainder_c >= remainder_b + 1:
                triplet_count += remainder_counts[remainder_a] * remainder_counts[remainder_b] * remainder_counts[remainder_c % divisor]

    #The above is because the total number of triplets need to be divisible.
    return triplet_count