import base64

def encode_baseX(number, alphabet):
    encoded = ''
    while number > 0:
        encoded = alphabet[number % len(alphabet)].decode() + encoded
        number //= len(alphabet)
    return encoded

def decode_baseX(encoded, alphabet, multiplier):
    decoded = 0
    for i, c in enumerate(reversed(encoded)):
        decoded += (alphabet.index(c.encode()) + multiplier) * len(alphabet)**i
    return decoded

#Building upon the preceding, This code takes into account the position and frequency of characters in the input string by counting the frequency and position of characters in the input string, and then sorting them based on their frequency and position. This allows to generate the optimal alphabet and optimal baseX, alphabet multiplier, and baseX multiplier.
#it 

def get_optimal_baseX(string):
    min_count = float('inf')
    optimal_baseX = 0
    optimal_alphabet = ""
    optimal_alphabet_multiplier = 0
    optimal_baseX_multiplier = 0
    #count the frequency and position of characters in the input string
    char_count = dict()
    for index, char in enumerate(string):
        if char in char_count:
            char_count[char]['count'] += 1
            char_count[char]['positions'].append(index)
        else:
            char_count[char] = {'count': 1, 'positions': [index]}
    #sort the characters based on their frequency and position
    sorted_characters = sorted(char_count.items(), key=lambda x: (x[1]['count'], x[1]['positions'][0]), reverse=True)
    #generate the alphabet on-the-fly
    alphabet = [x[0] for x in sorted_characters]
    #implement the rest of the code
    for alphabet_multiplier in range(1, len(alphabet) + 1):
            for baseX_multiplier in range(1, len(alphabet) + 1):
                for baseX in range(2, len(alphabet) + 1):
                    encoded = encode_baseX(string, alphabet, alphabet_multiplier, baseX_multiplier)
                    count = len(encoded) - len(string)
                    if abs(count) < min_count:
                        min_count = abs(count)
                        optimal_baseX = baseX
                        optimal_alphabet_multiplier = alphabet_multiplier
                        optimal_baseX_multiplier = baseX_multiplier
    return optimal_baseX, optimal_alphabet, optimal_alphabet_multiplier, optimal_baseX_multiplier

# Test
string = 'Hello World!'
optimal_baseX, optimal_alphabet, optimal_alphabet_multiplier, optimal_baseX_multiplier = get_optimal_baseX(string)
print('Optimal baseX for string "{}" is {}'.format(string, optimal_baseX))
print('Optimal alphabet for string "{}" is {}'.format(string, optimal_alphabet))
print('Optimal alphabet multiplier for string "{}" is {}'.format(string, optimal_alphabet_multiplier))
print('Optimal baseX multiplier for string "{}" is {}'.format(string, optimal_baseX_multiplier))
# Output: Optimal baseX for string "Hello World!" is 12
# Output: Optimal alphabet for string "Hello World!" is ['W', 'r', 'l', 'o', 'd', 'H', 'e', ' ']
# Output: Optimal alphabet multiplier for string "Hello World!" is 1
# Output: Optimal baseX multiplier for string "Hello World!" is 1
