Линейный рекуррентный регистр сдвига с обратной связью, реализация на python

def regt(reg1):
       def xor(s0, s3):
              s0 = int(s0)
              s3 = int(s3)
              new_s0=s0^s3
              return str(new_s0)
       reg_new=''
       while reg!=reg_new:
              print(reg1)
              reg_new = xor(reg1[3], reg1[0]) + reg1[:-1]
              reg1=reg_new
              
       return reg_new
 
 
reg='1111'
 
print(regt(reg))

class список: # пока читал про регистры, заодно и ООП освоил:)
     def __init__(self, base):
          self.base = base
     def __add__(self, a):
          self.base = self.base + a
     def __str__(self):
          return "%s " % self.base
 
M = список([])
 
def reg_t(fback, reg): 
#эта функция вызывается из функции max_len(), 
#Вообще она изначально должна была брать 2 последовательных состояния регистра 
#и давать следующее, ну и вот во что превратилась
    count1 = 0
    for j in range(len(fback)):
        if reg[j] == fback[j] == '1':
            count1+=1 
    reg2 = str(count1%2)+reg[:-1]
    return(reg2)
 
def max_len(fback): 
#принимает вектор обратной связи
#если с него получается последовательность 2^n-1(максимальной длины)
# то возвращает True
    t=2**len(fback)-1 #период последовательности макс. длины
    reg_all = ['1'*len(fback)] #тут просто начальное заполнение
    while True: 
#запускаем цикл с постусловием
        reg_all += [reg_t(fback, reg_all [-1])]
#крутим нашу шарманку до момента повтора
        if reg_t(fback, reg_all[-1]) in reg_all:
            break
    return len(reg_all) == t #если число состояний 2^n-1, значит последовательность максимальной длины
    #тогда вернет True
 
def LFSR(reg, fback):#имитируем работу регистра, функция принимает начальное заполнение
# и то, какие ячеки регистра падают в сумматор
    next_r, xor = reg, 0
    while True:
        for i in fback:
            xor += int(next_r[i-1])
        if xor%2 == 0:
            xor = 0
        else:
            xor = 1
        next_r = str(xor) + next_r[:-1]
        xor = 0
        print(next_r)
        if max_len(next_r) == True:
            M+[next_r]#собственно вот для этой красоты понадобилась перезагрузка;)
        if next_r == reg:
            break
 
 
LFSR('11111', (5, 1)) #заполняем регистр, указываем обратные связи
print(M)#вроде как ответ

LFSR('11111', (5,2))

def reg_t(fback, reg): 
    count1 = 0
    for j in range(len(fback)):
        if reg[j] == fback[j] == '1':
            count1+=1 
    reg2 = str(count1%2)+reg[:-1]
    return(reg2)
 
def max_len(fback): 
    t=2**len(fback)-1 
    reg_all = ['1'*len(fback)] 
    while True:
        if reg_t(fback, reg_all[-1]) in reg_all:
            break
        reg_all += [reg_t(fback, reg_all [-1])]
 
    return len(reg_all) == t
 
n=8
t=2**n-1
 
for i in range(1, t):
   if max_len(bin(i)[2:].zfill(n)):
        print((bin(i)[2:].zfill(n)))