#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# ZetpeR xax007@yandex.ru
# Дача кота Леопольда, или Особенности мышиной охоты

import os, sys, io, struct
from PIL import Image
import numpy as np

NAME = "Дача кота Леопольда, или Особенности мышиной охоты" 
FORMATS_ARCHIVE = ['00','01','02','03','04','05','06','07','08','09','10','11','12','13','14','15','16','17','bas']
TYPES_ARCHIVE = [('Дача кота Леопольда, или Особенности мышиной охоты', ('00','01','02','03','04','05','06','07','08','09','10','11','12','13','14','15','16','17','*.bas'))]
GAMES = ["Дача кота Леопольда, или Особенности мышиной охоты"]
AUTHOR = "ZetpeR xax007@yandex.ru"

class Game_Res:
    def __init__(self,app):
        self.file = None
        self.data = [] 
        self.app = app
        
        self.sup_formats = ["bmp",
                            "anm",
                            "wav"]
        self.sup_types = {"bmp":1,
                          "anm":2,
                          "wav":3}
        self.images = []   
        self.sound = None
        self.fwav = io.BytesIO() # Соединенные звуки

    def open_data(self,file):
        format = file.split(".")[-1].lower()
        (dirname, filename) = os.path.split(file)
        if filename in ['00','01','02','03','04','05','06','07','08','09','10','11','12','13','14','15','16','17']:
            self.OpenArchive00(file)
        elif format == "bas":
            self.OpenArchiveBAS(file)

    def unpack(self,data_res):
        self.images = []
        self.sound = None
        
        name = data_res[0]
        offset = data_res[1]
        size = data_res[2]
        format = data_res[3]
        self.file.seek(offset)
        if format == "bmp":
            self.Unpack_BMP(io.BytesIO(self.file.read(size)))
        elif format == "anm":
            self.Unpack_ANM(io.BytesIO(self.file.read(size)))
        elif format == "wav":
            self.Unpack_WAV(io.BytesIO(self.file.read(size)))

    def OpenArchive00(self,file):
        self.data = [] 
        f = open(file,"rb")
        data = [] # Список размеров
    
        size = struct.unpack("<I",f.read(4))[0] # Первый размер файла
        data.append(size)
        f.seek(12)
        col_f = struct.unpack("<I",f.read(4))[0] # Сколько прочитать размеров дальше
        for i in range(col_f): 
            size = struct.unpack("<I",f.read(4))[0] # Размеры файлов
            data.append(size)
        f.seek(232) # Начало файлов
        ss = 0
        for i in data:
            ss += 1
            offset = f.tell()
            tip1 = f.read(2) # Проверка на тип bmp

            f.seek(offset+583)
            tip2 = f.read(1) # Проверка на тип anm

            if tip1 == b'\x42\x4D': # bmp
                self.data.append((str(ss)+".bmp",offset,i,"bmp"))

            elif tip2 == b'\x03': # Анимация
                self.data.append((str(ss)+".anm",offset,i,"anm"))

            else: # Непонятно
                self.data.append((str(ss)+".bin",offset,i,"bin"))
                
            f.seek(offset+i) # Переход на начало следующего файла
        self.file = f
        
    def OpenArchiveBAS(self,file):
        f = open(file,"rb")
        data = [] # Список размеров
        col_f = struct.unpack("<I",f.read(4))[0] # Сколько прочитать файлов
        for i in range(col_f):
            size = struct.unpack("<I",f.read(4))[0]
            data.append((size))
        offset = f.tell() # Cделано чтоб правельно начинались звук wav
        f.seek(offset-4)
        ss = 0 # Номер файла
        for i in data:
            ss += 1
            offset = f.tell()
            tip1 = f.read(1) # Проверка на тип anm
            f.seek(offset)
            tip2 = f.read(2) # Проверка на тип bmp, wav

            if tip2 == b'\x42\x4D': # bmp
                self.data.append((str(ss)+".bmp",offset,i,"bmp"))
            
            elif tip2 == b'\x52\x49' or tip2 == b'\x54\xF8': # wav    tip2 это для первого звука в архиве GAME.BAS
                self.data.append((str(ss)+".wav",offset,i,"wav"))

            elif tip1 == b'\x03': # Анимация
                self.data.append((str(ss)+".anm",offset,i,"anm"))
            
            else: # Непонятно
                self.data.append((str(ss)+".bin",offset,i,"bin"))
                
            f.seek(offset+i) # Переход на начало следующего файла
        self.file = f
        return 1

    def Unpack_BMP(self, f):
        image = Image.open(f)
        self.images = [image]

    def Unpack_WAV(self, f):
        tip2 = f.read(4)
        if tip2 == b'\x54\xF8\x32\x00': # Для первого звука в архиве GAME.BAS
            f.seek(0)
            f.write(b'\x52\x49\x46\x46')
            self.sound = f
        else:    
            self.sound = f
            
    def Unpack_NEW_WAV(self):
        size = self.fwav.tell()
        if size > 0: # Если записан звук
            self.fwav.seek(0)
            fd = self.fwav.read()

            wav = b""
            wav += b"RIFF"
            wav += struct.pack("<I", size+44-8)# chunkSize размер файла-8
            wav += b"WAVE" # format WAVE
            wav += b"fmt " # subchunk1Id fmt 0x666d7420    
            subchunk1Size = 16 
            audioFormat = 1 
            numChannels = 1    # Количество каналов
            sampleRate = 22050 # Частота файла
            byteRate = 44100   # Частота выхода звука, для расчёта длины звучания
            blockAlign = 2
            bitsPerSample = 16 # Битность звука
            wav += struct.pack("<IHHIIHH", subchunk1Size, audioFormat, numChannels, sampleRate, byteRate, blockAlign, bitsPerSample)
            wav += b"data"
            wav += struct.pack("<I", size)
            wav += fd # Данные
            f3 = io.BytesIO(wav)
            self.sound = f3
            self.fwav = io.BytesIO() # Чистиим память
            
    def Unpack_ANM(self, f):
        f.seek(0,2)  
        end_f = f.tell()
        f.seek(0)
    
        check_1 = f.read(1) # Проверка
        f.seek(1025)
        check_2 = f.read(2) # Проверка 2
        if check_1 == b'\x03' and check_2 == b'\x05\x01': # Это Просто картинка
            List_sizes = [(0,end_f)]
            f.seek(1) # Переходим к началу палитры
        else:   
            f.seek(582)
            check_3 = f.read(2) # Проверка
            if check_3 == b'\x00\x03': # Это анимация
                #print("Это анимация")
                # Находимся на 584 байте, тут уже палитра
                List_sizes = self.Size_Anm(f,583,end_f) # Ищем размеры файлов анимации
                f.seek(584)

        #print("Нашлось",List_sizes)
        for it in List_sizes:
            end_f = it[1] # Это нужно для остановки

            f.seek(it[0])
            fd = f.read(it[1])
            f2 = io.BytesIO(fd)

            check_1 = f2.read(1) # Проверка это одна анимации
            f2.seek(1025)
            check_2 = f2.read(2) # Проверка 2
            if check_1 == b'\x03' and check_2 == b'\x05\x01':
                f2.seek(1) # Переходим к началу палитры
            else:
                print("Ошибка непонятно это картинка или нет")
                return(0)

            f5 = io.BytesIO() # Для чтнения палитры 
            for j in range(256): # Палитра 1024 байта
                b = f2.read(1)
                g = f2.read(1)
                r = f2.read(1)
                a = f2.read(1)
                
                f5.write(r)
                f5.write(g)
                f5.write(b)
            f5.seek(0)
            Pal = np.frombuffer(f5.read(256*3), dtype=np.uint8)
            Pal = np.array(Pal, np.uint8).reshape(256, 3)
            f5.close()

            unclear = struct.unpack("<H",f2.read(2))[0] # Непонятно блок что дальше будет размер сжатого файла
            size = struct.unpack("<I",f2.read(4))[0] # Размер одной сжатой картинки
            #print("Начало файла")
            #print("Непонятно",unclear,"Размер одной сжатой анимации",size,"\n")

            # Функцию флаг 1 создать картинку, если 0 используем уже созданную картинку, посылать в функцию img пустую "" если надо создать файл
            img = self.decompression(f2,1,Pal,"") # распаковываем данные Создаёт картинку 1
            self.images.append(img.copy()) # Делаем копию картинки
            #print("Распаковали главную картинку")

            # Читает дальше блоки после картинки
            while True:
                poz = f2.tell()
                while True:
                    if f2.tell() == end_f-1: # Остановка последний байт должен быть 00
                        #print("Достигли конца файла Проверка")
                        break
                    poz3 = f2.tell()
                    check = f2.read(1) # Проверка

                    if check == b'\x01':
                        size = struct.unpack("<I",f2.read(4))[0] # Размер блока
                        #print("Блок 01",poz,"Размер без заголовка",size)
                        img = self.decompression(f2,0,Pal,img)
                        self.images.append(img.copy()) # Делаем копию картинки
                        break

                    elif check == b'\x02':
                        #print("Блок 02 pass")
                        pass

                    elif check == b'\x03': # Это скорей звук
                        f2.seek(poz3+1) # Чтоб правельно прочетать размер файла
                        size = struct.unpack("<I",f2.read(4))[0] # Размер блока
                        #print("Блок 03 звук позиция",poz,"Размер без заголовка",size)
                        fd = f2.read(size)  
                        self.fwav.write(fd) # Запись
                        break

                    elif check == b'\x05':
                        #print("Блок 05 pass")
                        pass

                    else:
                        print("    Ошибка непонятные байты",check,f2.tell()-1)
                        return(0)

                if f2.tell() == end_f -1:
                    #print("Достигли конца файла 2")
                    break
            f2.close()
            img.close()

        f.close()
        #print()
        self.Unpack_NEW_WAV()

    def Size_Anm(self, f,offset,end_f): # Ищем размеры файлов анимации
        f.seek(0)
        List_sizes = [] # Список оффсетов и размеров файлов анимации
        while True:
            if f.tell() >= 583:
                break
            posf0 = f.tell()
            size = struct.unpack("<I",f.read(4))[0] # Возможный размер анимации
            #print("Позиция чтения размера",posf0,size)
            if offset+size <= end_f: # Это чтоб невызывало ошибок если значение получится больше файла
                f.seek(offset+size)
                posboz = f.tell() # Возможная позиция начало новой анимации
                #print("Зашли сюда 2 позиция",posboz)
                if posboz == end_f: # Дошли до конца файла
                    #print("    Дошли до конца файла",offset,size)
                    #print("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
                    List_sizes.append((offset,size)) # Сохранение данных последней анимации
                    break

                check_1 = f.read(1) # Проверка
                #print("Проверка",check_1,posboz,"Размер",size)
                if check_1 == b'\x03' and size > 0: # Это возможно анимация
                    f.seek(posboz+1025)
                    check_2 = f.read(2) # Проверка 2
                    if check_2 == b'\x05\x01' or check_2 == b'\x05\x05' and f.tell() == 1541707: # Это анимация # Исправление b'\x05\x05' для файла 14 4 5368423.anm
                        #print("    Это анимация Оффсет и размер",offset,size)
                        List_sizes.append((offset,size))
                        offset += size # Новое начало анимации
                        f.seek(posf0+1)

                    else: # Если это 4 байта небыли размером анимации
                        f.seek(posf0+1)
                else: # Если это 4 байта небыли размером анимации
                    f.seek(posf0+1)
            else: # Если это 4 байта небыли размером анимации
                f.seek(posf0+1)
        return(List_sizes)
        
    def Save(self,f2,ss,Pal,img,block_w,block_h,w,h):
        # Виртуальный распакованный файл, Номер распакованного блока, Палитра, Большая картинка, Сколько блоков по ширине, И высоте, Где должен находится следующий блок в большой картинки по ширине w, И высоте h.
        
        f2.seek(0) # Создаём блок в виде картинки
        rgb_pal = np.frombuffer(f2.read(8*8), dtype=np.uint8)
        rgb = Pal[rgb_pal]
        rgb = rgb.reshape(8, 8, 3)
        f_image = Image.fromarray(rgb, "RGB") # Готовое изображение

        # Накладываем блок 8 на 8 картинки на большую картинку
        img.paste(f_image,(w,h)) # Вставляем изображение по координатам Ширина и высота
        w += 8
        if ss%block_w == 0: # Значит мы переходим на на новый блок в высоту Номер блока ss
            h += 8 # Прибавляем к высоте
            w = 0  # Ставим оффсет на чало строчки

        f_image.close()
        f2.close()
        return(w,h)
        
    def write_del_bit(self,f2,fd,Biu,col_del_bit): # Записывает байт и удаляет биты
        f2.write(fd)          
        for i in range(col_del_bit): # Количество удалений
            del Biu[0] # Удаляем использованный биты
            
    def decompression(self,f,flag,Pal,img):
        block_w = struct.unpack("B",f.read(1))[0] # Количество блоков в ширину
        block_h = struct.unpack("B",f.read(1))[0] # Количество блоков в высоту
        #print("Количество блоков в ширину",block_w,"Высоту",block_h,"Всего блоков",block_w*block_h)
        #print("Реальная ширина картинки",block_w*8,"Высоту",block_h*8)

        if flag == 1: # Создать картинку
            img = Image.new("RGB", (block_w*8,block_h*8)) # Создание новой картинки
        w = 0 # Это оффсет наложения в ширину на одной линии по ширине картинки
        h = 0 # Это оффсет наложения в высоту

        col = struct.unpack("<H",f.read(2))[0]-2 # Сколько прочетать управляющих байтов
        Cb = [] # Управляющие биты
        for i in range(col):
            ba = struct.unpack("B",f.read(1))[0] # Прочитать байт
            bits = [(ba & (2 ** i))>>i for i in range(8)][::-1] # Биты в правельном порядке
            Cb.extend(bits) # Расширяет список list, добавляя в конец все элементы списка L
        #print("Позиция",f.tell())

        ss = 0 # Блок который распаковываем
        while True:
            ss += 1
            if ss > block_w*block_h: # Когда распакуем все блоки
                break
            #print("Находемся",f.tell(),"Блок номер",ss)   
            if Cb[0] == 0: # Пропускаем блок
                #print("  Зашли в бит 0")
                for i in range(1): # Удаляем использованных битов
                    del Cb[0]
                    
                w += 8
                if ss%block_w == 0: # Значит мы переходим на новый блок в высоту Номер блока ss
                    h += 8 # Прибавляем к высоте
                    w = 0  # Ставим оффсет на чало строчки

            elif Cb[0] == 1 and Cb[1] == 0 and Cb[2] == 0 and Cb[3] == 1: # Повторить 64 раза 1 байт
                #print("  Зашли в 1001")
                for i in range(4): # Удаляем использованных битов
                    del Cb[0]
                fd = f.read(1)
                #print("Байт который надо повторить 64 раза",fd)
                f2 = io.BytesIO()
                for i in range(64):
                    f2.write(fd)
                w,h = self.Save(f2,ss,Pal,img,block_w,block_h,w,h)

            elif Cb[0] == 1 and Cb[1] == 0 and Cb[2] == 1 and Cb[3] == 0: # Биты 0, 1
                #print("  Зашли в 1010")
                for i in range(4): # Удаляем использованных битов
                    del Cb[0]
                f2 = io.BytesIO()
                Biu = [] # Список битов для распаковки
                bx1 = f.read(1) # Первый байт Бит 0
                bx2 = f.read(1) # Второй байт Бит 1
                while True:
                    if f2.tell() == 64:
                        #print("Достигли конца распаковки")
                        break
                    ba = struct.unpack("B",f.read(1))[0] # Прочитать байт
                    bits = [(ba & (2 ** i))>>i for i in range(8)][::-1] # Биты в правельном порядке
                    Biu.extend(bits) # Расширяет список list, добавляя в конец все элементы списка L
                    while True:
                        if f2.tell() == 64:
                            #print("Достигли конца распаковки")
                            break
                        if len(Biu) == 0: # Если в списке не осталось бит
                            break

                        if Biu[0] == 0:
                            f2.write(bx1)
                        elif Biu[0] == 1:
                            f2.write(bx2)
                        del Biu[0] # Удаляем использованный биты
                w,h = self.Save(f2,ss,Pal,img,block_w,block_h,w,h)

            elif Cb[0] == 1 and Cb[1] == 0 and Cb[2] == 1 and Cb[3] == 1: # Биты 0, 10, 11
                #print("  Зашли в 1011")
                for i in range(4): # Удаляем использованных битов
                    del Cb[0]
                f2 = io.BytesIO()
                Biu = [] # Список битов для распаковки
                bx1 = f.read(1) # Бит 0
                bx2 = f.read(1) # Бит 10
                bx3 = f.read(1) # Бит 11
                while True:
                    if f2.tell() == 64:
                        #print("Достигли конца распаковки")
                        break
                    ba = struct.unpack("B",f.read(1))[0] # Прочитать байт
                    bits = [(ba & (2 ** i))>>i for i in range(8)][::-1] # Биты в правельном порядке
                    Biu.extend(bits) # Расширяет список list, добавляя в конец все элементы списка L
                    while True:
                        if f2.tell() == 64:
                            #print("Достигли конца распаковки")
                            break
                        if len(Biu) == 0: # Если в списке не осталось бит
                            break
                            
                        if f2.tell() > 64: # Если в списке не осталось бит
                            print("Ошибка")
                            return(0)
                            
                        if Biu[0] == 0:
                            self.write_del_bit(f2,bx1,Biu,1)
                        elif len(Biu) >= 2 and Biu[0] == 1 and Biu[1] == 0:
                            self.write_del_bit(f2,bx2,Biu,2)
                        elif len(Biu) >= 2 and Biu[0] == 1 and Biu[1] == 1:
                            self.write_del_bit(f2,bx3,Biu,2)
                        else:
                            break
                w,h = self.Save(f2,ss,Pal,img,block_w,block_h,w,h)

            elif Cb[0] == 1 and Cb[1] == 1 and Cb[2] == 0 and Cb[3] == 0: # Биты 0, 01, 10, 11
                #print("  Зашли в 1100")
                for i in range(4): # Удаляем использованных битов
                    del Cb[0]
                f2 = io.BytesIO()
                Biu = [] # Список битов для распаковки
                bx1 = f.read(1) # Бит 00
                bx2 = f.read(1) # Бит 01
                bx3 = f.read(1) # Бит 10
                bx4 = f.read(1) # Бит 11
                while True:
                    if f2.tell() == 64:
                        #print("Достигли конца распаковки")
                        break
                    ba = struct.unpack("B",f.read(1))[0] # Прочитать байт
                    bits = [(ba & (2 ** i))>>i for i in range(8)][::-1] # Биты в правельном порядке
                    Biu.extend(bits) # Расширяет список list, добавляя в конец все элементы списка L
                    while True:
                        #print(Biu)
                        if f2.tell() == 64:
                            #print("Достигли конца распаковки")
                            break
                        if len(Biu) == 0: # Если в списке не осталось бит
                            break
                            
                        if f2.tell() > 64: # Ошибка переполнения
                            print("Ошибка переполнения")
                            return(0)
                            
                        if len(Biu) >= 2 and Biu[0] == 0 and Biu[1] == 0:
                            self.write_del_bit(f2,bx1,Biu,2)
                        elif len(Biu) >= 2 and Biu[0] == 0 and Biu[1] == 1:
                            self.write_del_bit(f2,bx2,Biu,2)
                        elif len(Biu) >= 2 and Biu[0] == 1 and Biu[1] == 0:
                            self.write_del_bit(f2,bx3,Biu,2)
                        elif len(Biu) >= 2 and Biu[0] == 1 and Biu[1] == 1:
                            self.write_del_bit(f2,bx4,Biu,2)
                        else:
                            break
                w,h = self.Save(f2,ss,Pal,img,block_w,block_h,w,h)

            elif Cb[0] == 1 and Cb[1] == 1 and Cb[2] == 0 and Cb[3] == 1: # Биты 000, 001, 010, 011, 100, 101, 110, 111
                #print("  Зашли в 1101")
                for i in range(4): # Удаляем использованных битов
                    del Cb[0]
                col = struct.unpack("B",f.read(1))[0] # Сколько прочетать байтов
                if col in [5,6,7,8]: # Это известные количество байтов которое можно прочетать
                    pass
                else:
                    print("Ошибка надо прочетать больше или меньше 5-8 байт",col,f.tell()-1)
                    return(0)
                
                f2 = io.BytesIO()
                Biu = [] # Список битов для распаковки
                bx1 = f.read(1) # Бит 000
                bx2 = f.read(1) # Бит 001
                bx3 = f.read(1) # Бит 010
                bx4 = f.read(1) # Бит 011
                bx5 = f.read(1) # Бит 100
                if col >= 6: # Если больше 5 байт надо прочетать
                    bx6 = f.read(1) # Бит 101
                if col >= 7:
                    bx7 = f.read(1) # Бит 110
                if col >= 8:
                    bx8 = f.read(1) # Бит 111

                while True:
                    if f2.tell() == 64:
                        #print("Достигли конца распаковки")
                        break
                    ba = struct.unpack("B",f.read(1))[0] # Прочитать байт
                    bits = [(ba & (2 ** i))>>i for i in range(8)][::-1] # Биты в правельном порядке
                    Biu.extend(bits) # Расширяет список list, добавляя в конец все элементы списка L
                    while True:
                        #print(Biu)
                        if f2.tell() == 64:
                            #print("Достигли конца распаковки")
                            break
                        if len(Biu) == 0: # Если в списке не осталось бит
                            break
                            
                        if f2.tell() > 64: # Ошибка переполнения
                            print("Ошибка переполнения")
                            return(0)
                            
                        if len(Biu) >= 3 and Biu[0] == 0 and Biu[1] == 0 and Biu[2] == 0:
                            self.write_del_bit(f2,bx1,Biu,3)
                        elif len(Biu) >= 3 and Biu[0] == 0 and Biu[1] == 0 and Biu[2] == 1:
                            self.write_del_bit(f2,bx2,Biu,3)
                        elif len(Biu) >= 3 and Biu[0] == 0 and Biu[1] == 1 and Biu[2] == 0:
                            self.write_del_bit(f2,bx3,Biu,3)
                        elif len(Biu) >= 3 and Biu[0] == 0 and Biu[1] == 1 and Biu[2] == 1:
                            self.write_del_bit(f2,bx4,Biu,3)
                        elif len(Biu) >= 3 and Biu[0] == 1 and Biu[1] == 0 and Biu[2] == 0:
                            self.write_del_bit(f2,bx5,Biu,3)
                        elif len(Biu) >= 3 and Biu[0] == 1 and Biu[1] == 0 and Biu[2] == 1:
                            self.write_del_bit(f2,bx6,Biu,3)
                        elif len(Biu) >= 3 and Biu[0] == 1 and Biu[1] == 1 and Biu[2] == 0:
                            self.write_del_bit(f2,bx7,Biu,3)
                        elif len(Biu) >= 3 and Biu[0] == 1 and Biu[1] == 1 and Biu[2] == 1:
                            self.write_del_bit(f2,bx8,Biu,3)
                        else:
                            break
                w,h = self.Save(f2,ss,Pal,img,block_w,block_h,w,h)

            elif Cb[0] == 1 and Cb[1] == 1 and Cb[2] == 1 and Cb[3] == 0: # Биты 0000, 0001, 0010, 0011, 0100, 0101, 0110, 0111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111
                #print("  Зашли в 1110")
                for i in range(4): # Удаляем использованных битов
                    del Cb[0]
                col = struct.unpack("B",f.read(1))[0] # Сколько прочетать байтов
                if col in [9,10,11,12,13,14,15,16]: # Это известные количество байтов которое можно прочетать
                    pass
                else:
                    print("Ошибка надо прочетать больше или меньше 9-16 байт:",col,f.tell()-1)
                    return(0)
                
                f2 = io.BytesIO()
                Biu = [] # Список битов для распаковки
                bx1 = f.read(1) # Бит 0000
                bx2 = f.read(1) # Бит 0001
                bx3 = f.read(1) # Бит 0010
                if col >= 4:
                    bx4 = f.read(1) # Бит 0011
                if col >= 5:
                    bx5 = f.read(1) # Бит 0100
                if col >= 6:
                    bx6 = f.read(1) # Бит 0101
                if col >= 7:
                    bx7 = f.read(1) # Бит 0110
                if col >= 8:
                    bx8 = f.read(1) # Бит 0111
                if col >= 9:
                    bx9 = f.read(1) # Бит 1000
                if col >= 10:
                    bx10 = f.read(1) # Бит 1001
                if col >= 11:
                    bx11 = f.read(1) # Бит 1010
                if col >= 12:
                    bx12 = f.read(1) # Бит 1011
                if col >= 13:
                    bx13 = f.read(1) # Бит 1100
                if col >= 14:
                    bx14 = f.read(1) # Бит 1101
                if col >= 15:
                    bx15 = f.read(1) # Бит 1110
                if col >= 16:
                    bx16 = f.read(1) # Бит 1111

                while True:
                    if f2.tell() == 64:
                        #print("Достигли конца распаковки")
                        break
                    ba = struct.unpack("B",f.read(1))[0] # Прочитать байт
                    bits = [(ba & (2 ** i))>>i for i in range(8)][::-1] # Биты в правельном порядке
                    Biu.extend(bits) # Расширяет список list, добавляя в конец все элементы списка L
                    while True:
                        #print(Biu)
                        if len(Biu) > 32: # Если в списке больше 32 бит
                            print("ОШИБКА ПЕРЕПОЛНЕНИЕ ПОТОКОВОГО НАКОПИТЕЛЯ БИТ")
                            return(0)
                        
                        if f2.tell() == 64:
                            #print("Достигли конца распаковки")
                            break
                        if len(Biu) == 0: # Если в списке не осталось бит
                            break
                            
                        if f2.tell() > 64: # Ошибка переполнения
                            print("Ошибка переполнения")
                            return(0)
                            
                        if len(Biu) >= 4 and Biu[0] == 0 and Biu[1] == 0 and Biu[2] == 0 and Biu[3] == 0:
                            self.write_del_bit(f2,bx1,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 0 and Biu[1] == 0 and Biu[2] == 0 and Biu[3] == 1:
                            self.write_del_bit(f2,bx2,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 0 and Biu[1] == 0 and Biu[2] == 1 and Biu[3] == 0:
                            self.write_del_bit(f2,bx3,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 0 and Biu[1] == 0 and Biu[2] == 1 and Biu[3] == 1:
                            self.write_del_bit(f2,bx4,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 0 and Biu[1] == 1 and Biu[2] == 0 and Biu[3] == 0:
                            self.write_del_bit(f2,bx5,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 0 and Biu[1] == 1 and Biu[2] == 0 and Biu[3] == 1:
                            self.write_del_bit(f2,bx6,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 0 and Biu[1] == 1 and Biu[2] == 1 and Biu[3] == 0:
                            self.write_del_bit(f2,bx7,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 0 and Biu[1] == 1 and Biu[2] == 1 and Biu[3] == 1:
                            self.write_del_bit(f2,bx8,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 1 and Biu[1] == 0 and Biu[2] == 0 and Biu[3] == 0:
                            self.write_del_bit(f2,bx9,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 1 and Biu[1] == 0 and Biu[2] == 0 and Biu[3] == 1:
                            self.write_del_bit(f2,bx10,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 1 and Biu[1] == 0 and Biu[2] == 1 and Biu[3] == 0:
                            self.write_del_bit(f2,bx11,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 1 and Biu[1] == 0 and Biu[2] == 1 and Biu[3] == 1:
                            self.write_del_bit(f2,bx12,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 1 and Biu[1] == 1 and Biu[2] == 0 and Biu[3] == 0:
                            self.write_del_bit(f2,bx13,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 1 and Biu[1] == 1 and Biu[2] == 0 and Biu[3] == 1:
                            self.write_del_bit(f2,bx14,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 1 and Biu[1] == 1 and Biu[2] == 1 and Biu[3] == 0:
                            self.write_del_bit(f2,bx15,Biu,4)
                        elif len(Biu) >= 4 and Biu[0] == 1 and Biu[1] == 1 and Biu[2] == 1 and Biu[3] == 1:
                            self.write_del_bit(f2,bx16,Biu,4)
                        else:
                            break
                w,h = self.Save(f2,ss,Pal,img,block_w,block_h,w,h)

            elif Cb[0] == 1 and Cb[1] == 1 and Cb[2] == 1 and Cb[3] == 1: # Просто прочетать 64 байта
                #print("  Зашли в 1111")
                for i in range(4): # Удаляем использованных битов
                    del Cb[0]
                fd = f.read(64) # Просто прочетать байты
                f2 = io.BytesIO(fd)
                w,h = self.Save(f2,ss,Pal,img,block_w,block_h,w,h)
            else:
                print("Ошибка непонятная команда",Cb,"Позиция",f.tell())
                return(0)

        #print("Коцец распаковки сжатия",f.tell(),"\n")
        return(img)