public static Bitmap UnswizzleWithPalette(GMIO imageInfo, byte[] data, Dictionary<int, RGBA> palette)
        {
            //Inizializzo un buffer per l'intera lunghezza dei dati
            byte[] buffer = new byte[data.Length];

            int w = (imageInfo.TextureWidth * imageInfo.BitPerPixel) / 8;

            //Lunghezza del tile
            int lineSize = 16;
            //Grandezza del tile ( 16 colonne, 8 righe se ricordo bene )
            int tileSize = lineSize * 8;

            //Numero di blocchi da 8 di righe?
            int rowBlocks = w / lineSize;

            //Same as Upper
            int totalBlocksX = w / lineSize;
            //Numero di blocchi che formano l'altezza? Non saprei come definirlo in termine tecnico...
            int totalBlocksY = imageInfo.TextureHeight / 8;

            for (int blockY = 0; blockY < totalBlocksY; blockY++)
            {
                for (int blockX = 0; blockX < totalBlocksX; blockX++)
                {
                    //Dove inizia il blocco corrente
                    int block_index = blockX + blockY * rowBlocks;
                    //Indirizzo al blocco corrente
                    int block_address = (block_index * tileSize) % imageInfo.Palette.PointerPalette;

                    for (int y = 0; y < 8; y++)
                        for (int x = 0; x < lineSize; x++)
                        {
                            //Pixel corrente X sulla riga
                            int absolutex = x + blockX * lineSize;
                            //Pixel Corrente Y sulla colonna?
                            int absolutey = y + blockY * 8;

                            //Il punto corretto in cui dev'essere posizionato il pixel, moltiplicato per non so cosa
                            buffer[absolutex + absolutey * w] =
                                data[block_address + x + y * lineSize];
                            //Il pixel si trova all'indirizzo di questo blocco, più x ed y, che si spostano a seconda della lunghezza della riga
                        }
                }
            }

            //Dati "extra" vicino alla fine dello stream?
            int start = totalBlocksY*rowBlocks*lineSize*8;
            for (int i = start; i < data.Length; i++)
                buffer[i] = data[i];

            //Risetto i pixel nel giusto ordine
            Bitmap bmp = new Bitmap(imageInfo.TextureWidth, imageInfo.TextureHeight);
            int cont = 0;
            for (int i = 0; i < imageInfo.TextureHeight; i++)
            {
                for (int j = 0; j < imageInfo.TextureWidth; j++)
                {
                    if (imageInfo.BitPerPixel == 8)
                    {
                        var colorPixel = palette[buffer[cont]];
                        bmp.SetPixel(j, i, Color.FromArgb(colorPixel.A, colorPixel.R, colorPixel.G, colorPixel.B));
                    }
                    else if (imageInfo.BitPerPixel == 4)
                    {
                        //4 Bit Per Pixel Codec: se i byte sono letti come Little Endian, bisogna leggere i primi 4 bit e gli ultimi 4 bit del
                        //singolo byte per poter ricavare i due pixel vicini che ricostruiscono correttamente l'immagine.
                        //Info: nibble
                        var firstPixel = buffer[cont] & 0x0F;
                        var secondPixel = buffer[cont] >> 4;

                        var colorPixel = palette[firstPixel];
                        bmp.SetPixel(j, i, Color.FromArgb(255, colorPixel.R, colorPixel.G, colorPixel.B));

                        colorPixel = palette[secondPixel];
                        bmp.SetPixel(++j, i, Color.FromArgb(255, colorPixel.R, colorPixel.G, colorPixel.B));
                    }

                    cont++;
                }
            }

            return bmp;
        }