Откуда берутся жестко закодированные значения в алгоритмах хеширования / сжатия / кодирования

Question

Мне интересно, как решаются такие вещи, как эти :

for (var i = rounds; i > 0; i -= 2) {
  x[ 4] ^= R(x[ 0]+x[12], 7);  x[ 8] ^= R(x[ 4]+x[ 0], 9);
  x[12] ^= R(x[ 8]+x[ 4],13);  x[ 0] ^= R(x[12]+x[ 8],18);
  x[ 9] ^= R(x[ 5]+x[ 1], 7);  x[13] ^= R(x[ 9]+x[ 5], 9);
  x[ 1] ^= R(x[13]+x[ 9],13);  x[ 5] ^= R(x[ 1]+x[13],18);
  x[14] ^= R(x[10]+x[ 6], 7);  x[ 2] ^= R(x[14]+x[10], 9);
  x[ 6] ^= R(x[ 2]+x[14],13);  x[10] ^= R(x[ 6]+x[ 2],18);
  x[ 3] ^= R(x[15]+x[11], 7);  x[ 7] ^= R(x[ 3]+x[15], 9);
  x[11] ^= R(x[ 7]+x[ 3],13);  x[15] ^= R(x[11]+x[ 7],18);
  x[ 1] ^= R(x[ 0]+x[ 3], 7);  x[ 2] ^= R(x[ 1]+x[ 0], 9);
  x[ 3] ^= R(x[ 2]+x[ 1],13);  x[ 0] ^= R(x[ 3]+x[ 2],18);
  x[ 6] ^= R(x[ 5]+x[ 4], 7);  x[ 7] ^= R(x[ 6]+x[ 5], 9);
  x[ 4] ^= R(x[ 7]+x[ 6],13);  x[ 5] ^= R(x[ 4]+x[ 7],18);
  x[11] ^= R(x[10]+x[ 9], 7);  x[ 8] ^= R(x[11]+x[10], 9);
  x[ 9] ^= R(x[ 8]+x[11],13);  x[10] ^= R(x[ 9]+x[ 8],18);
  x[12] ^= R(x[15]+x[14], 7);  x[13] ^= R(x[12]+x[15], 9);
  x[14] ^= R(x[13]+x[12],13);  x[15] ^= R(x[14]+x[13],18);
}

То есть это набор конкретных жестко закодированных значений.Мне интересно, что входит в принятие таких решений, чтобы понять это как решение.Мне было бы интересно узнать, если:

1. Это сделано методом проб и ошибок каким-то образом.
2. Если нет, если есть какой-то метод к безумию.

Это еще один пример:

// Gamma0
var gamma0xh = w[(i-15) * 2];
var gamma0xl = w[(i-15) * 2 + 1];
var gamma0h =
  ((gamma0xl << 31) | (gamma0xh >>> 1)) ^
  ((gamma0xl << 24) | (gamma0xh >>> 8)) ^
   (gamma0xh >>> 7);
var gamma0l =
  ((gamma0xh << 31) | (gamma0xl >>> 1)) ^
  ((gamma0xh << 24) | (gamma0xl >>> 8)) ^
  ((gamma0xh << 25) | (gamma0xl >>> 7));

// Gamma1
var gamma1xh = w[(i-2) * 2];
var gamma1xl = w[(i-2) * 2 + 1];
var gamma1h =
  ((gamma1xl << 13) | (gamma1xh >>> 19)) ^
  ((gamma1xh << 3)  | (gamma1xl >>> 29)) ^
   (gamma1xh >>> 6);
var gamma1l =
  ((gamma1xh << 13) | (gamma1xl >>> 19)) ^
  ((gamma1xl << 3)  | (gamma1xh >>> 29)) ^
  ((gamma1xh << 26) | (gamma1xl >>> 6));

Существует множество других примеров этого в различных алгоритмах хеширования и кодировании.