быстрее или медленнее по сравнению с чем?

по сравнению с 16 битным алгоритмом

странный вопрос для питона, у него битность платформы вообще ни на что не влияет

а кандидат математических наук считает, что влияет

ну кандидат математических наук однозначно шарит в питоне лучше всех в этом чате

можно я его тут процитирую?

может он не так уж и не прав?

как никак он кандидат!

У питона динамическая типизация, он почти на каждый чих проверяет то, какого типа операнды (даже на обычное сложение). Кроме того, так как размеры чисел не ограничены (бесконечная встроенная длина), то перед тем, как питон выполнит заветные add rax, rbx он сделает столько лишних операций, что тебе должно быть пофиг - там 16-битные, 32-битные или 64-битные регистры используются.
Но чем выше битность платформы, тем бОльшими числами может оперировать программа на уровне ассемблера, а значит и в среднем скорость выше.

Это ты просто не знаешь, что там питон 1.5 и калечное железо

как раз знаю
и страшно представить, насколько всё хуже по сравнению с тем, что я описал.
кому вообще пришло в голову ставить древний питон на слабое железо?

Ну, кто-то же еще купил это) как говорится они нашли друг друга

Есть спрос

8ми битный AES выполнялся 30 секунд, 32 - 1,5 секунды

+ это гибридный алго, использующий 4 кб констант в виде таблиц

и совмещающий в себе несколько преобразований

# Apply round transforms
#print rounds
#for r in range(1, rounds):
   
       a[0] = (T1[(t[ 0 ] >> 24) & 0xFF] ^
               T2[(t[ 1 ] >> 16) & 0xFF] ^
               T3[(t[ 2 ] >>  8) & 0xFF] ^
               T4[ t[ 3 ]        & 0xFF] ^
               Ke[1][0])

       a[1] = (T1[(t[ 1 ] >> 24) & 0xFF] ^
               T2[(t[ 2 ] >> 16) & 0xFF] ^
               T3[(t[ 3 ] >>  8) & 0xFF] ^
               T4[ t[ 0 ]        & 0xFF] ^
               Ke[1][1])

       a[2] = (T1[(t[ 2 ] >> 24) & 0xFF] ^
               T2[(t[ 3 ] >> 16) & 0xFF] ^
               T3[(t[ 0 ] >>  8) & 0xFF] ^
               T4[ t[ 1 ]        & 0xFF] ^
               Ke[1][2])

       a[3] = (T1[(t[ 3 ] >> 24) & 0xFF] ^
               T2[(t[ 0 ] >> 16) & 0xFF] ^
               T3[(t[ 1 ] >>  8) & 0xFF] ^
               T4[ t[ 2 ]        & 0xFF] ^
               Ke[1][3])    
       a, t = t, a
#    t = list(a)

       a[0] = (T1[(t[ 0 ] >> 24) & 0xFF] ^
               T2[(t[ 1 ] >> 16) & 0xFF] ^
               T3[(t[ 2 ] >>  8) & 0xFF] ^
               T4[ t[ 3 ]        & 0xFF] ^
               Ke[2][0])

       a[1] = (T1[(t[ 1 ] >> 24) & 0xFF] ^
               T2[(t[ 2 ] >> 16) & 0xFF] ^
               T3[(t[ 3 ] >>  8) & 0xFF] ^
               T4[ t[ 0 ]        & 0xFF] ^
               Ke[2][1])

       a[2] = (T1[(t[ 2 ] >> 24) & 0xFF] ^
               T2[(t[ 3 ] >> 16) & 0xFF] ^
               T3[(t[ 0 ] >>  8) & 0xFF] ^
               T4[ t[ 1 ]        & 0xFF] ^
               Ke[2][2])

       a[3] = (T1[(t[ 3 ] >> 24) & 0xFF] ^
               T2[(t[ 0 ] >> 16) & 0xFF] ^
               T3[(t[ 1 ] >>  8) & 0xFF] ^
               T4[ t[ 2 ]        & 0xFF] ^
               Ke[2][3])    
       a, t = t, a

вот вам два раунда в таком алгоритме

всего их 9

Хоспаде
Шёл второй месяц, а Dim всё не купит норм железо