Ошибка при подсчете функции

Снова вопросы по этой проге, теперь только 2 вопроса. 1. В

s16Transformation() 

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

mas[i] = s16[x&hexBasis[i]] & hexBasis[i];

в чем может быть ошибка?

2. Правильна ли сама логика записи функции? Сами функции дальше на скрине:

Их реализация в коде:

//S 
int s16Transformation(int x) {
    long long mas[8];
    for (int i = 0; i<8; ++i) {
         mas[i] = s16[x&hexBasis[i]] & hexBasis[i];  //ошибка
    }
    int S = 0;
    for (int i = 0; i<8; ++i) {
         S |= mas[i];
    }
    return S;
}
//D
int dTransformation(int j, int i) {
    int S_j = s16Transformation(i);
    int L_j = linearTransformation(S_j);
    L_j ^= consts[j];
    int S = s16Transformation(L_j);
    int L = linearTransformation(S);
    return L^consts[j];
}
//F
int fTranformation(int x, int k) {
    int S = s16Transformation(x^k);
    return linearTransformation(S);
}

Весь код выглядит так:

#include <iostream>
#include <sstream>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
typedef vector<long long> masInt;
//ключ
const int key = 0x4a567bed;
//начальный вектор инициализации, _H0
const int H0 = 0x2b838811;
//подстановка степени 16 _s
const long long s16[] = {
      11, 7, 9, 0,
      8, 5, 12, 1,
      2, 15, 3, 13,
      14, 6, 10, 4 };
//обратная подстановка _s_reverse
const int s16Reverse[] = {
      3, 7, 8, 10,
      15, 5, 13, 1,
      4, 2, 14, 0,
      6, 11, 12, 9 };
//массив констант _C
const int consts[] = {
      0x8e20faa7,
      0x2ba0b470,
      0x47017ddd,
      0x9b505a38,
      0xad08b0c0,
      0xc3282d1c,
      0xd8045870,
      0xef14980e,
      0x6c022c38,
      0xf90a4c07,
      0x3601161c,
      0xf205268d };
//массив для выделения полубайтов hex_basis
const int hexBasis[] = {
      0x0000000f,
      0x000000f0,
      0x00000f00,
      0x0000f000,
      0x000f0000,
      0x00f00000,
      0x0f000000,
      0xf0000000 };
const int basis[] = {
      0x00000001, 0x00000002, 0x00000004, 0x00000008,
      0x00000010, 0x00000020, 0x00000040, 0x00000080,
      0x00000100, 0x00000200, 0x00000400, 0x00000800,
      0x00001000, 0x00002000, 0x00004000, 0x00008000,
      0x00010000, 0x00020000, 0x00040000, 0x00080000,
      0x00100000, 0x00200000, 0x00400000, 0x00800000,
      0x01000000, 0x02000000, 0x04000000, 0x08000000,
      0x10000000, 0x20000000, 0x40000000, 0x80000000 };
//подстановка степени 32 _pi
const int s32[] = { 0, 8, 16, 24, 1, 19, 17, 25, 2, 10, 18, 26, 3, 11, 19,
         27, 4, 12, 20, 28, 5, 13, 21, 29, 6, 14, 22, 30, 7, 15, 23, 31 };
//обратная подстановка _pi_reverse
const int s32Reverse[]{
      0, 4, 8, 12, 16, 20, 24, 28,
      1, 5, 9, 13, 17, 21, 25, 29,
      2, 6, 10, 14, 18, 22, 26, 30,
      3, 7, 11, 15, 19, 23, 27, 31 };
//линейное преобразование L
int linearTransformation(int x) {
    int mas[32];
    for (int i = 0; i<32; ++i) {
         mas[i] = x&basis[s32[i]];
    }
    int L = 0;
    for (int i = 0; i<32; ++i) {
         L |= mas[i];
    }
    return L;
}
//преобразование, основанное на подстановке s16, это S
int s16Transformation(int x) {
    long long mas[8];
    for (int i = 0; i<8; ++i) {
         mas[i] = s16[x&hexBasis[i]] & hexBasis[i];  //ошибка
    }
    int S = 0;
    for (int i = 0; i<8; ++i) {
         S |= mas[i];
    }
    return S;
}
//обратное преобразование
int s16ReverseTransformation(int x) {
    int mas[8];
    for (int i = 0; i<8; ++i) {
         mas[i] = s16Reverse[x&hexBasis[i]] & hexBasis[i];
    }
    int S_reverse = 0;
    for (int i = 0; i<8; ++i) {
         S_reverse |= mas[i];
    }
    return S_reverse;
}
//преобразование по условию это D
int dTransformation(int j, int i) {
    int S_j = s16Transformation(i);
    int L_j = linearTransformation(S_j);
    L_j ^= consts[j];
    int S = s16Transformation(L_j);
    int L = linearTransformation(S);
    return L^consts[j];
}
//преобразование по условию, это F
int fTranformation(int x, int k) {
    int S = s16Transformation(x^k);
    return linearTransformation(S);
}
//массив раундовых ключей
masInt keys(int key) {
    masInt K(12);
    for (int i = 0; i<12; ++i) {
         for (int j = 0; j<11; ++j) {
              key = fTranformation(dTransformation(i, j), key);
         }
         K[i] = key^dTransformation(i, 11);
         key = K[i];
    }
    return K;
}
//результат шифрования 32-х битного блока x на ключе k
int encryptionResult(int x, int key) {
     masInt K = keys(key);
     int i=0;
     for (int j = 0; j<11; ++j) {
          x = fTranformation(K[j], x);
     }
     return K[11] ^ x;
 }
 //функция сжатия в общем виде
 int functionCompression(int x, int k, int H) {
     return encryptionResult(k, (x^H));
 }
  //вычисление H по Ex(H) = y и x
  int encryptionResultReverse(int x, int y) {
      //вычислим раундовые ключи x0,...,x11
      masInt X = keys(x);
      //вычислим H за 11 раундов
      y ^= X[11];
      for (int i = 0; i<12; ++i) {
           y = s16ReverseTransformation(linearTransformation(y)) ^ X[10 - i];
      }
      return y;
  }
 //хэш-функция
 int functionHash(masInt x) {
     int H = H0;
     for (int i = 0; i<x.size(); ++i) {
          H = functionCompression(x[i], key, H);
     }
     return H;
 }
 //преобразование строки в hex массив
 masInt MkHexMasFromStr() {
    cout << "Введите x в 16-ричном виде" << endl;
    string x_string;
    cin >> x_string;
    //дополним входное сообщение нулями
    while (x_string.size() % 8 != 0) {
           x_string.push_back('0');
    }
    masInt x_mas(x_string.size() / 8);
    //создадим hex-массив
    int i=0;
    while(i<x_string.size()){
          stringstream x_stream;
          x_stream <<dec<< x_string.substr(i, 8); //делит массив
          x_stream >> x_mas[i/8];
          i+=8;
    }
    return x_mas;
}
//основная программа
int main() {
    setlocale(LC_ALL, "Russian");
    masInt x1_mas = MkHexMasFromStr();
    //вычислим хэш сообщения
    int H1 = functionHash(x1_mas);
    cout<<"H1= "<<H1;
    return 0;
}