def sum_of_k_mirror_numbers_brute_force(k_base, number_of_mirror_numbers):

    valid_numbers_found = 0
    current_number = 1
    sum_of_mirror_numbers = 0

    while valid_numbers_found < number_of_mirror_numbers:
        # Check if the number is a palindrome in base 10
        if is_palindrome_base_ten(current_number):

            # Check if the number is also a palindrome in the other base
            if is_palindrome_other_base(current_number, k_base):
                # Accumulate the sum and increment our counter
                sum_of_mirror_numbers += current_number
                valid_numbers_found += 1

        current_number += 1

    return sum_of_mirror_numbers

def is_palindrome_base_ten(number):
    number_string = str(number)
    return number_string == number_string[::-1]

def is_palindrome_other_base(number, k_base):
    converted_number = convert_to_base_k(number, k_base)
    return converted_number == converted_number[::-1]

def convert_to_base_k(number, k_base):
    if number == 0:
        return "0"

    digits = []

    # Repeatedly get the remainders and divide the number
    while number:
        digits.append(str(number % k_base))
        number //= k_base

    # Now reverse the digits to get the result
    return "".join(digits[::-1])

def sum_k_mirror_numbers(k_base, number_of_terms):
    def is_palindrome(number_string):
        return number_string == number_string[::-1]

    def convert_to_base_k(number, k_base):
        if number == 0:
            return '0'
        digits = []
        while number:
            digits.append(str(number % k_base))
            number //= k_base
        return ''.join(digits[::-1])

    def generate_palindromes():
        # Start with single digit palindromes
        for i in range(1, 10):
            yield str(i)

        length = 2
        while True:
            # Generate odd length palindromes
            for middle_digit in range(10):
                half = str(10**(length // 2))
                start = int(half)
                end = int(str(10**(length // 2 +1) -1))
                for i in range(start,end+1):
                    string_num = str(i)
                    palindrome = string_num + str(middle_digit) + string_num[::-1]
                    yield palindrome

            # Generate even length palindromes
            half = str(10**(length // 2-1))
            start = int(half)
            end = int(str(10**(length // 2) -1))
            for i in range(start,end+1):
                string_num = str(i)
                palindrome = string_num + string_num[::-1]
                yield palindrome
            length += 1

    sum_of_mirror_numbers = 0
    count = 0

    #Iterate through generator
    for potential_palindrome in generate_palindromes():
        decimal_representation = int(potential_palindrome)
        #Only analyze when sufficient terms have not been reached
        if count < number_of_terms:
            if is_palindrome(str(decimal_representation)):
                base_k_representation = convert_to_base_k(decimal_representation, k_base)

                #Ensure the base K is a palindrome
                if is_palindrome(base_k_representation):
                    sum_of_mirror_numbers += decimal_representation
                    count += 1
        else:
            break
    
    return sum_of_mirror_numbers