По поводу команд - наверное я снимаю свое предложение. Особо большого выигрыша по скорости не получится (особо учитывая то, что ещё надо сдвигать), а геморрою много.

Вот пара примеров циклов простой замены по ГОСТ:
Первый пример - упакованный узел замену, оптимизация отсутствует

//-------------------------------------------------------------
// Замена по узлу замены
// Меняем входные 32 бита на выходные
//-------------------------------------------------------------
dword subst(dword ak)
{
 dword v;
 dword m;
 int i;
 v = 0;
 m = 0x0F;
 for (i = 0; i < 8; i++)
  {
   v |= uz[ak & 0xF] & m;
   ak >>= 4;
   m <<= 4;
  }
 return v;
}

//-------------------------------------------------------------
// Простая замена (8 раундов)
// Вход: k - указатель на ключ, step = +1 или -1
//-------------------------------------------------------------
void pz8(dword *k, int step)
{
 dword ak;
 int i;
 for (i = 0; i < 8; i++)
  {
   ak = N1 + *k;
   ak = subst(ak);
   ak = (ak << 11) | (ak >> 32-11);
   ak ^= N2;
   N2 = N1;
   N1 = ak;
   k += step;
  }
}

//-------------------------------------------------------------
// Простая замена - зашифрование, 07 07 07 70
//-------------------------------------------------------------
void pz_e(dword *k)
{
 pz8(k, 1);
 pz8(k, 1);
 pz8(k, 1);
 pz8(k+7, -1);
}

//-------------------------------------------------------------
// Простая замена - расшифрование, 07 70 70 70
//-------------------------------------------------------------
void pz_d(dword *k)
{
 pz8(k, 1);
 pz8(k+7, -1);
 pz8(k+7, -1);
 pz8(k+7, -1);
}

//-------------------------------------------------------------
// Простая замена - имитоприставка 07 07
//-------------------------------------------------------------
void pz_i(dword *k)
{
 pz8(k, 1);
 pz8(k, 1);
}

Второй пример - узел замены распакован, оптимизация под ARM

T_BIG_UZ big_uz;
dword NN[4];
// 07 07              0  1  2  3   4  5  6  7   0  1  2  3   4  5  6  7
const schar PZ_I[] = {1, 1, 1, 1,  1, 1, 1,-7,  1, 1, 1, 1,  1, 1, 1, 2};

// 07 07 07 70        0  1  2  3   4  5  6  7   0  1  2  3   4  5  6  7
const schar PZ_E[] = {1, 1, 1, 1,  1, 1, 1,-7,  1, 1, 1, 1,  1, 1, 1,-7,
//                    0  1  2  3   4  5  6  7   7  6  5  4   3  2  1  0
                      1, 1, 1, 1,  1, 1, 1, 0, -1,-1,-1,-1, -1,-1,-1, 2};

// 07 70 70 70        0  1  2  3   4  5  6  7   7  6  5  4   3  2  1  0
const schar PZ_D[] = {1, 1, 1, 1,  1, 1, 1, 0, -1,-1,-1,-1, -1,-1,-1, 7,
//                    7  6  5  4   3  2  1  0   7  6  5  4   3  2  1  0
                     -1,-1,-1,-1, -1,-1,-1, 7, -1,-1,-1,-1, -1,-1,-1, 2};


//-------------------------------------------------------------
//-------------------------------------------------------------

__arm  __ramfunc  void pz(const dword *k, const schar *mode)
{
 dword ak;
 dword tmp;
 dword tmp2;

 do
  {
   ak = NN[0] + *k;

   tmp = big_uz.uz[0][ak & 0xFF];
   tmp2 = (tmp << 11) | (tmp >> (32 - 11));
   ak >>= 8;
   tmp = big_uz.uz[1][ak & 0xFF];
   tmp2 |= (tmp << 11 + 8) | (tmp >> (32 - 11 - 8));
   ak >>= 8;
   tmp = big_uz.uz[2][ak & 0xFF];
   tmp2 |= (tmp << 11 + 16) | (tmp >> (32 - 11 - 16));
   ak >>= 8;
   tmp = big_uz.uz[3][ak & 0xFF];
   tmp2 |= (tmp << 11 + 24 - 32) | (tmp >> (32 - 11 - 24 + 32));
   ak = tmp2;

   ak ^= NN[1];
   NN[1] = NN[0];
   NN[0] = ak;
   k += *mode;
  } while (*mode++ != 2);
}





//-------------------------------------------------------------
// Подготовка узла замены
// Формат распакованного:
// byte uz[4][256];
// Старший индекс (4) - номер байта в слове
// Младший индекс (256) - байт
//-------------------------------------------------------------
void ConvUZ(const byte *stdUZ)
{
 int i;
 int h;
 int l;
 for (i = 0; i < 4; i++)
  {
   for (h = 0; h < 16; h++)
     for (l = 0; l < 16; l++)
      {
       big_uz.uz[i][h * 16 + l] = (stdUZ[i + l * 4] & 0x0F) |
                           (stdUZ[i + h * 4] & 0xF0);
      }
  }
}