char *ntlm_crypt(char *key) {
  int i, j;
  int length = strlen(key);
  unsigned int nt_buffer[16], a, b, c, d, sqrt2, sqrt3, n, output[4];
  static char hex_format[33];
  char itoa16[16] = "0123456789abcdef";
  memset(nt_buffer, 0, 16 * sizeof(unsigned int));
  for (i = 0; i < length / 2; i++)
    nt_buffer[i] = key[2 * i] | (key[2 * i + 1] << 16);
  if (length % 2 == 1)
    nt_buffer[i] = key[length - 1] | 0x800000;
  else
    nt_buffer[i] = 0x80;
  nt_buffer[14] = length << 4;
  output[0] = a = 0x67452301;
  output[1] = b = 0xefcdab89;
  output[2] = c = 0x98badcfe;
  output[3] = d = 0x10325476;
  sqrt2 = 0x5a827999;
  sqrt3 = 0x6ed9eba1;
  a += (d ^ (b & (c ^ d))) + nt_buffer[0];
  a = (a << 3) | (a >> 29);
  d += (c ^ (a & (b ^ c))) + nt_buffer[1];
  d = (d << 7) | (d >> 25);
  c += (b ^ (d & (a ^ b))) + nt_buffer[2];
  c = (c << 11) | (c >> 21);
  b += (a ^ (c & (d ^ a))) + nt_buffer[3];
  b = (b << 19) | (b >> 13);
  a += (d ^ (b & (c ^ d))) + nt_buffer[4];
  a = (a << 3) | (a >> 29);
  d += (c ^ (a & (b ^ c))) + nt_buffer[5];
  d = (d << 7) | (d >> 25);
  c += (b ^ (d & (a ^ b))) + nt_buffer[6];
  c = (c << 11) | (c >> 21);
  b += (a ^ (c & (d ^ a))) + nt_buffer[7];
  b = (b << 19) | (b >> 13);
  a += (d ^ (b & (c ^ d))) + nt_buffer[8];
  a = (a << 3) | (a >> 29);
  d += (c ^ (a & (b ^ c))) + nt_buffer[9];
  d = (d << 7) | (d >> 25);
  c += (b ^ (d & (a ^ b))) + nt_buffer[10];
  c = (c << 11) | (c >> 21);
  b += (a ^ (c & (d ^ a))) + nt_buffer[11];
  b = (b << 19) | (b >> 13);
  a += (d ^ (b & (c ^ d))) + nt_buffer[12];
  a = (a << 3) | (a >> 29);
  d += (c ^ (a & (b ^ c))) + nt_buffer[13];
  d = (d << 7) | (d >> 25);
  c += (b ^ (d & (a ^ b))) + nt_buffer[14];
  c = (c << 11) | (c >> 21);
  b += (a ^ (c & (d ^ a))) + nt_buffer[15];
  b = (b << 19) | (b >> 13);
  a += ((b & (c | d)) | (c & d)) + nt_buffer[0] + sqrt2;
  a = (a << 3) | (a >> 29);
  d += ((a & (b | c)) | (b & c)) + nt_buffer[4] + sqrt2;
  d = (d << 5) | (d >> 27);
  c += ((d & (a | b)) | (a & b)) + nt_buffer[8] + sqrt2;
  c = (c << 9) | (c >> 23);
  b += ((c & (d | a)) | (d & a)) + nt_buffer[12] + sqrt2;
  b = (b << 13) | (b >> 19);
  a += ((b & (c | d)) | (c & d)) + nt_buffer[1] + sqrt2;
  a = (a << 3) | (a >> 29);
  d += ((a & (b | c)) | (b & c)) + nt_buffer[5] + sqrt2;
  d = (d << 5) | (d >> 27);
  c += ((d & (a | b)) | (a & b)) + nt_buffer[9] + sqrt2;
  c = (c << 9) | (c >> 23);
  b += ((c & (d | a)) | (d & a)) + nt_buffer[13] + sqrt2;
  b = (b << 13) | (b >> 19);
  a += ((b & (c | d)) | (c & d)) + nt_buffer[2] + sqrt2;
  a = (a << 3) | (a >> 29);
  d += ((a & (b | c)) | (b & c)) + nt_buffer[6] + sqrt2;
  d = (d << 5) | (d >> 27);
  c += ((d & (a | b)) | (a & b)) + nt_buffer[10] + sqrt2;
  c = (c << 9) | (c >> 23);
  b += ((c & (d | a)) | (d & a)) + nt_buffer[14] + sqrt2;
  b = (b << 13) | (b >> 19);
  a += ((b & (c | d)) | (c & d)) + nt_buffer[3] + sqrt2;
  a = (a << 3) | (a >> 29);
  d += ((a & (b | c)) | (b & c)) + nt_buffer[7] + sqrt2;
  d = (d << 5) | (d >> 27);
  c += ((d & (a | b)) | (a & b)) + nt_buffer[11] + sqrt2;
  c = (c << 9) | (c >> 23);
  b += ((c & (d | a)) | (d & a)) + nt_buffer[15] + sqrt2;
  b = (b << 13) | (b >> 19);
  a += (d ^ c ^ b) + nt_buffer[0] + sqrt3;
  a = (a << 3) | (a >> 29);
  d += (c ^ b ^ a) + nt_buffer[8] + sqrt3;
  d = (d << 9) | (d >> 23);
  c += (b ^ a ^ d) + nt_buffer[4] + sqrt3;
  c = (c << 11) | (c >> 21);
  b += (a ^ d ^ c) + nt_buffer[12] + sqrt3;
  b = (b << 15) | (b >> 17);
  a += (d ^ c ^ b) + nt_buffer[2] + sqrt3;
  a = (a << 3) | (a >> 29);
  d += (c ^ b ^ a) + nt_buffer[10] + sqrt3;
  d = (d << 9) | (d >> 23);
  c += (b ^ a ^ d) + nt_buffer[6] + sqrt3;
  c = (c << 11) | (c >> 21);
  b += (a ^ d ^ c) + nt_buffer[14] + sqrt3;
  b = (b << 15) | (b >> 17);
  a += (d ^ c ^ b) + nt_buffer[1] + sqrt3;
  a = (a << 3) | (a >> 29);
  d += (c ^ b ^ a) + nt_buffer[9] + sqrt3;
  d = (d << 9) | (d >> 23);
  c += (b ^ a ^ d) + nt_buffer[5] + sqrt3;
  c = (c << 11) | (c >> 21);
  b += (a ^ d ^ c) + nt_buffer[13] + sqrt3;
  b = (b << 15) | (b >> 17);
  a += (d ^ c ^ b) + nt_buffer[3] + sqrt3;
  a = (a << 3) | (a >> 29);
  d += (c ^ b ^ a) + nt_buffer[11] + sqrt3;
  d = (d << 9) | (d >> 23);
  c += (b ^ a ^ d) + nt_buffer[7] + sqrt3;
  c = (c << 11) | (c >> 21);
  b += (a ^ d ^ c) + nt_buffer[15] + sqrt3;
  b = (b << 15) | (b >> 17);
  output[0] += a;
  output[1] += b;
  output[2] += c;
  output[3] += d;
  for (i = 0; i < 4; i++)
    for (j = 0, n = output[i]; j < 4; j++) {
      unsigned int convert = n % 256;
      hex_format[i * 8 + j * 2 + 1] = itoa16[convert % 16];
      convert = convert / 16;
      hex_format[i * 8 + j * 2 + 0] = itoa16[convert % 16];
      n = n / 256;
    }
  hex_format[33] = 0;
  return hex_format;
}


x86 assembly (clang, -O0):
<ntlm_crypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
mov    0xebe(%rip),%rax
mov    %rax,-0xa0(%rbp)
mov    0xeb8(%rip),%rax
mov    %rax,-0x98(%rbp)
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1040 <memset@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa8(%rbp),%eax
cmp    %ecx,%eax
jge    11d2 <ntlm_crypt+0xb2>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rax,%rdx,1),%eax
shl    $0x10,%eax
or     %eax,%ecx
movslq -0xc(%rbp),%rax
mov    %ecx,-0x60(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    116e <ntlm_crypt+0x4e>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    120a <ntlm_crypt+0xea>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
or     $0x800000,%ecx
movslq -0xc(%rbp),%rax
mov    %ecx,-0x60(%rbp,%rax,4)
jmp    1216 <ntlm_crypt+0xf6>
movslq -0xc(%rbp),%rax
movl   $0x80,-0x60(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x28(%rbp)
movl   $0x67452301,-0x64(%rbp)
movl   $0x67452301,-0x90(%rbp)
23 45 67
movl   $0xefcdab89,-0x68(%rbp)
movl   $0xefcdab89,-0x8c(%rbp)
ab cd ef
movl   $0x98badcfe,-0x6c(%rbp)
movl   $0x98badcfe,-0x88(%rbp)
dc ba 98
movl   $0x10325476,-0x70(%rbp)
movl   $0x10325476,-0x84(%rbp)
54 32 10
movl   $0x5a827999,-0x74(%rbp)
movl   $0x6ed9eba1,-0x78(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x68(%rbp),%ecx
mov    -0x6c(%rbp),%edx
xor    -0x70(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x64(%rbp),%ecx
mov    -0x68(%rbp),%edx
xor    -0x6c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x5c(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x7,%eax
mov    -0x70(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x70(%rbp),%ecx
mov    -0x64(%rbp),%edx
xor    -0x68(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x58(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0xb,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
xor    -0x64(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x54(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0x13,%eax
mov    -0x68(%rbp),%ecx
shr    $0xd,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x68(%rbp),%ecx
mov    -0x6c(%rbp),%edx
xor    -0x70(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x50(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x64(%rbp),%ecx
mov    -0x68(%rbp),%edx
xor    -0x6c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x4c(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x7,%eax
mov    -0x70(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x70(%rbp),%ecx
mov    -0x64(%rbp),%edx
xor    -0x68(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x48(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0xb,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
xor    -0x64(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x44(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0x13,%eax
mov    -0x68(%rbp),%ecx
shr    $0xd,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x68(%rbp),%ecx
mov    -0x6c(%rbp),%edx
xor    -0x70(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x40(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x64(%rbp),%ecx
mov    -0x68(%rbp),%edx
xor    -0x6c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x3c(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x7,%eax
mov    -0x70(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x70(%rbp),%ecx
mov    -0x64(%rbp),%edx
xor    -0x68(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x38(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0xb,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
xor    -0x64(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x34(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0x13,%eax
mov    -0x68(%rbp),%ecx
shr    $0xd,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x68(%rbp),%ecx
mov    -0x6c(%rbp),%edx
xor    -0x70(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x30(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x64(%rbp),%ecx
mov    -0x68(%rbp),%edx
xor    -0x6c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x2c(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x7,%eax
mov    -0x70(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x70(%rbp),%ecx
mov    -0x64(%rbp),%edx
xor    -0x68(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x28(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0xb,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
xor    -0x64(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0x13,%eax
mov    -0x68(%rbp),%ecx
shr    $0xd,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x6c(%rbp),%ecx
or     -0x70(%rbp),%ecx
and    %ecx,%eax
mov    -0x6c(%rbp),%ecx
and    -0x70(%rbp),%ecx
or     %ecx,%eax
add    -0x60(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x68(%rbp),%ecx
or     -0x6c(%rbp),%ecx
and    %ecx,%eax
mov    -0x68(%rbp),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
add    -0x50(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x5,%eax
mov    -0x70(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x64(%rbp),%ecx
or     -0x68(%rbp),%ecx
and    %ecx,%eax
mov    -0x64(%rbp),%ecx
and    -0x68(%rbp),%ecx
or     %ecx,%eax
add    -0x40(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0x9,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
or     -0x64(%rbp),%ecx
and    %ecx,%eax
mov    -0x70(%rbp),%ecx
and    -0x64(%rbp),%ecx
or     %ecx,%eax
add    -0x30(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0xd,%eax
mov    -0x68(%rbp),%ecx
shr    $0x13,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x6c(%rbp),%ecx
or     -0x70(%rbp),%ecx
and    %ecx,%eax
mov    -0x6c(%rbp),%ecx
and    -0x70(%rbp),%ecx
or     %ecx,%eax
add    -0x5c(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x68(%rbp),%ecx
or     -0x6c(%rbp),%ecx
and    %ecx,%eax
mov    -0x68(%rbp),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
add    -0x4c(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x5,%eax
mov    -0x70(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x64(%rbp),%ecx
or     -0x68(%rbp),%ecx
and    %ecx,%eax
mov    -0x64(%rbp),%ecx
and    -0x68(%rbp),%ecx
or     %ecx,%eax
add    -0x3c(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0x9,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
or     -0x64(%rbp),%ecx
and    %ecx,%eax
mov    -0x70(%rbp),%ecx
and    -0x64(%rbp),%ecx
or     %ecx,%eax
add    -0x2c(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0xd,%eax
mov    -0x68(%rbp),%ecx
shr    $0x13,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x6c(%rbp),%ecx
or     -0x70(%rbp),%ecx
and    %ecx,%eax
mov    -0x6c(%rbp),%ecx
and    -0x70(%rbp),%ecx
or     %ecx,%eax
add    -0x58(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x68(%rbp),%ecx
or     -0x6c(%rbp),%ecx
and    %ecx,%eax
mov    -0x68(%rbp),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
add    -0x48(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x5,%eax
mov    -0x70(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x64(%rbp),%ecx
or     -0x68(%rbp),%ecx
and    %ecx,%eax
mov    -0x64(%rbp),%ecx
and    -0x68(%rbp),%ecx
or     %ecx,%eax
add    -0x38(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0x9,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
or     -0x64(%rbp),%ecx
and    %ecx,%eax
mov    -0x70(%rbp),%ecx
and    -0x64(%rbp),%ecx
or     %ecx,%eax
add    -0x28(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0xd,%eax
mov    -0x68(%rbp),%ecx
shr    $0x13,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x6c(%rbp),%ecx
or     -0x70(%rbp),%ecx
and    %ecx,%eax
mov    -0x6c(%rbp),%ecx
and    -0x70(%rbp),%ecx
or     %ecx,%eax
add    -0x54(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x68(%rbp),%ecx
or     -0x6c(%rbp),%ecx
and    %ecx,%eax
mov    -0x68(%rbp),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
add    -0x44(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x5,%eax
mov    -0x70(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x64(%rbp),%ecx
or     -0x68(%rbp),%ecx
and    %ecx,%eax
mov    -0x64(%rbp),%ecx
and    -0x68(%rbp),%ecx
or     %ecx,%eax
add    -0x34(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0x9,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
or     -0x64(%rbp),%ecx
and    %ecx,%eax
mov    -0x70(%rbp),%ecx
and    -0x64(%rbp),%ecx
or     %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0xd,%eax
mov    -0x68(%rbp),%ecx
shr    $0x13,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
add    -0x60(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
add    -0x40(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x9,%eax
mov    -0x70(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
xor    -0x70(%rbp),%eax
add    -0x50(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0xb,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
xor    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
add    -0x30(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0xf,%eax
mov    -0x68(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
add    -0x58(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
add    -0x38(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x9,%eax
mov    -0x70(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
xor    -0x70(%rbp),%eax
add    -0x48(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0xb,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
xor    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
add    -0x28(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0xf,%eax
mov    -0x68(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
add    -0x5c(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
add    -0x3c(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x9,%eax
mov    -0x70(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
xor    -0x70(%rbp),%eax
add    -0x4c(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0xb,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
xor    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
add    -0x2c(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0xf,%eax
mov    -0x68(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
add    -0x54(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x3,%eax
mov    -0x64(%rbp),%ecx
shr    $0x1d,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
add    -0x34(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shl    $0x9,%eax
mov    -0x70(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
xor    -0x70(%rbp),%eax
add    -0x44(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
shl    $0xb,%eax
mov    -0x6c(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
xor    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
add    -0x24(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shl    $0xf,%eax
mov    -0x68(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x64(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x68(%rbp),%eax
add    -0x8c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x70(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jge    1b84 <ntlm_crypt+0xa64>
movl   $0x0,-0x10(%rbp)
movslq -0xc(%rbp),%rax
mov    -0x90(%rbp,%rax,4),%eax
mov    %eax,-0x7c(%rbp)
cmpl   $0x4,-0x10(%rbp)
jge    1b71 <ntlm_crypt+0xa51>
mov    -0x7c(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
and    $0xf,%eax
mov    %eax,%eax
mov    -0xa0(%rbp,%rax,1),%dl
mov    -0xc(%rbp),%eax
shl    $0x3,%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    0x2528(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0xa4(%rbp),%eax
shr    $0x4,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
and    $0xf,%eax
mov    %eax,%eax
mov    -0xa0(%rbp,%rax,1),%dl
mov    -0xc(%rbp),%eax
shl    $0x3,%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x0,%eax
movslq %eax,%rcx
lea    0x24e9(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x7c(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1ad3 <ntlm_crypt+0x9b3>
jmp    1b76 <ntlm_crypt+0xa56>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1ab4 <ntlm_crypt+0x994>
movb   $0x0,0x24d6(%rip)
lea    0x24ae(%rip),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ntlm_crypt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %rax,%r14
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
shr    $0x1f,%eax
add    %r14d,%eax
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    %r14d,%ecx
sub    %edx,%ecx
cmp    $0x2,%r14d
jl     116c <ntlm_crypt+0x5c>
sar    %eax
mov    %eax,%eax
mov    %r14d,%edx
and    $0xfffffffe,%edx
cmp    $0x2,%edx
jne    1170 <ntlm_crypt+0x60>
xor    %edx,%edx
jmp    11ae <ntlm_crypt+0x9e>
xor    %eax,%eax
jmp    11c4 <ntlm_crypt+0xb4>
mov    %eax,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsbl (%rbx,%rdx,2),%edi
movsbl 0x1(%rbx,%rdx,2),%ebp
shl    $0x10,%ebp
or     %edi,%ebp
mov    %ebp,0x40(%rsp,%rdx,4)
movsbl 0x2(%rbx,%rdx,2),%edi
movsbl 0x3(%rbx,%rdx,2),%ebp
shl    $0x10,%ebp
or     %edi,%ebp
mov    %ebp,0x44(%rsp,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1180 <ntlm_crypt+0x70>
test   $0x1,%al
je     11c4 <ntlm_crypt+0xb4>
movsbl (%rbx,%rdx,2),%esi
movsbl 0x1(%rbx,%rdx,2),%edi
shl    $0x10,%edi
or     %esi,%edi
mov    %edi,0x40(%rsp,%rdx,4)
mov    $0x80,%edx
cmp    $0x1,%ecx
jne    11e1 <ntlm_crypt+0xd1>
mov    %r14d,%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
movsbl (%rbx,%rcx,1),%edx
or     $0x800000,%edx
mov    %edx,0x40(%rsp,%rax,4)
mov    0x40(%rsp),%eax
mov    0x44(%rsp),%ecx
mov    %rcx,0x10(%rsp)
lea    -0x1(%rax),%r11d
mov    %rax,%r12
mov    %rax,0x88(%rsp)
rol    $0x3,%r11d
mov    %r11d,%eax
and    $0x77777777,%eax
xor    $0x98badcfe,%eax
lea    (%rcx,%rax,1),%r10d
add    $0x10325476,%r10d
rol    $0x7,%r10d
mov    %r11d,%eax
xor    $0xefcdab89,%eax
and    %r10d,%eax
xor    $0xefcdab89,%eax
mov    0x48(%rsp),%ecx
mov    %rcx,0x90(%rsp)
lea    (%rcx,%rax,1),%edx
add    $0x98badcfe,%edx
rol    $0xb,%edx
mov    %r10d,%eax
xor    %r11d,%eax
and    %edx,%eax
xor    %r11d,%eax
mov    0x4c(%rsp),%ecx
mov    %rcx,0x18(%rsp)
add    %ecx,%eax
add    $0xefcdab89,%eax
rol    $0x13,%eax
mov    %edx,%ecx
xor    %r10d,%ecx
and    %eax,%ecx
xor    %r10d,%ecx
mov    0x50(%rsp),%r8d
add    %r8d,%r11d
mov    %r8d,0x28(%rsp)
add    %ecx,%r11d
rol    $0x3,%r11d
mov    %eax,%ecx
xor    %edx,%ecx
and    %r11d,%ecx
xor    %edx,%ecx
mov    0x54(%rsp),%esi
add    %esi,%r10d
mov    %esi,%r15d
mov    %esi,0x38(%rsp)
add    %ecx,%r10d
rol    $0x7,%r10d
mov    %r11d,%ecx
xor    %eax,%ecx
and    %r10d,%ecx
xor    %eax,%ecx
mov    0x58(%rsp),%esi
mov    %esi,0x34(%rsp)
add    %esi,%edx
add    %ecx,%edx
rol    $0xb,%edx
mov    %r10d,%ecx
xor    %r11d,%ecx
and    %edx,%ecx
xor    %r11d,%ecx
mov    0x5c(%rsp),%esi
mov    %esi,0xc(%rsp)
add    %esi,%eax
add    %ecx,%eax
rol    $0x13,%eax
mov    %edx,%ecx
xor    %r10d,%ecx
and    %eax,%ecx
xor    %r10d,%ecx
mov    0x60(%rsp),%esi
add    %esi,%r11d
mov    %esi,%ebx
add    %ecx,%r11d
rol    $0x3,%r11d
mov    %eax,%ecx
xor    %edx,%ecx
and    %r11d,%ecx
xor    %edx,%ecx
mov    0x64(%rsp),%r13d
add    %r13d,%r10d
mov    %r13d,0x2c(%rsp)
add    %ecx,%r10d
rol    $0x7,%r10d
mov    %r11d,%ecx
xor    %eax,%ecx
and    %r10d,%ecx
xor    %eax,%ecx
mov    0x68(%rsp),%esi
mov    %esi,0x24(%rsp)
add    %esi,%edx
add    %ecx,%edx
rol    $0xb,%edx
mov    %r10d,%ecx
xor    %r11d,%ecx
and    %edx,%ecx
xor    %r11d,%ecx
mov    0x6c(%rsp),%esi
mov    %esi,0x3c(%rsp)
add    %esi,%eax
add    %ecx,%eax
rol    $0x13,%eax
mov    %edx,%ecx
xor    %r10d,%ecx
and    %eax,%ecx
xor    %r10d,%ecx
mov    0x70(%rsp),%ebp
add    %ebp,%r11d
add    %ecx,%r11d
rol    $0x3,%r11d
mov    %eax,%ecx
xor    %edx,%ecx
and    %r11d,%ecx
xor    %edx,%ecx
mov    0x74(%rsp),%edi
add    %edi,%r10d
mov    %edi,0x30(%rsp)
add    %ecx,%r10d
rol    $0x7,%r10d
shl    $0x4,%r14d
mov    %r11d,%ecx
xor    %eax,%ecx
and    %r10d,%ecx
xor    %eax,%ecx
add    %r14d,%edx
add    %ecx,%edx
rol    $0xb,%edx
mov    %r10d,%ecx
xor    %r11d,%ecx
and    %edx,%ecx
xor    %r11d,%ecx
mov    0x7c(%rsp),%esi
mov    %esi,0x8(%rsp)
add    %esi,%eax
add    %ecx,%eax
rol    $0x13,%eax
mov    %edx,%ecx
or     %r10d,%ecx
and    %eax,%ecx
mov    %edx,%r9d
and    %r10d,%r9d
or     %ecx,%r9d
add    %r12d,%r11d
add    %r9d,%r11d
add    $0x5a827999,%r11d
rol    $0x3,%r11d
mov    %eax,%ecx
or     %edx,%ecx
and    %r11d,%ecx
mov    %eax,%r9d
and    %edx,%r9d
or     %ecx,%r9d
add    %r8d,%r10d
add    %r9d,%r10d
add    $0x5a827999,%r10d
rol    $0x5,%r10d
mov    %r11d,%ecx
or     %eax,%ecx
and    %r10d,%ecx
mov    %r11d,%r9d
and    %eax,%r9d
or     %ecx,%r9d
add    %ebx,%edx
add    %edx,%r9d
add    $0x5a827999,%r9d
rol    $0x9,%r9d
mov    %r10d,%ecx
or     %r11d,%ecx
and    %r9d,%ecx
mov    %r10d,%edx
and    %r11d,%edx
or     %ecx,%edx
add    %ebp,%eax
add    %edx,%eax
add    $0x5a827999,%eax
rol    $0xd,%eax
mov    %r9d,%ecx
or     %r10d,%ecx
and    %eax,%ecx
mov    %r9d,%edx
and    %r10d,%edx
or     %ecx,%edx
add    0x10(%rsp),%r11d
add    %edx,%r11d
add    $0x5a827999,%r11d
rol    $0x3,%r11d
mov    %eax,%ecx
or     %r9d,%ecx
and    %r11d,%ecx
mov    %eax,%edx
and    %r9d,%edx
or     %ecx,%edx
add    %r15d,%r10d
add    %edx,%r10d
add    $0x5a827999,%r10d
rol    $0x5,%r10d
mov    %r11d,%ecx
or     %eax,%ecx
and    %r10d,%ecx
mov    %r11d,%edx
and    %eax,%edx
or     %ecx,%edx
add    %r13d,%r9d
add    %edx,%r9d
add    $0x5a827999,%r9d
rol    $0x9,%r9d
mov    %r10d,%ecx
or     %r11d,%ecx
and    %r9d,%ecx
mov    %r10d,%edx
and    %r11d,%edx
or     %ecx,%edx
add    %edi,%eax
add    %edx,%eax
add    $0x5a827999,%eax
rol    $0xd,%eax
mov    %r9d,%ecx
or     %r10d,%ecx
and    %eax,%ecx
mov    %r9d,%edx
and    %r10d,%edx
or     %ecx,%edx
mov    0x90(%rsp),%rsi
add    %esi,%r11d
add    %edx,%r11d
add    $0x5a827999,%r11d
rol    $0x3,%r11d
mov    %eax,%ecx
or     %r9d,%ecx
and    %r11d,%ecx
mov    %eax,%edx
and    %r9d,%edx
or     %ecx,%edx
mov    0x34(%rsp),%r8d
add    %r8d,%r10d
add    %edx,%r10d
add    $0x5a827999,%r10d
rol    $0x5,%r10d
mov    %r11d,%ecx
or     %eax,%ecx
and    %r10d,%ecx
mov    %r11d,%edx
and    %eax,%edx
or     %ecx,%edx
mov    0x24(%rsp),%edi
add    %edi,%r9d
add    %edx,%r9d
add    $0x5a827999,%r9d
rol    $0x9,%r9d
mov    %r10d,%ecx
or     %r11d,%ecx
and    %r9d,%ecx
mov    %r10d,%edx
and    %r11d,%edx
or     %ecx,%edx
add    %r14d,%eax
add    %edx,%eax
add    $0x5a827999,%eax
rol    $0xd,%eax
mov    %r9d,%ecx
or     %r10d,%ecx
and    %eax,%ecx
mov    %r9d,%edx
and    %r10d,%edx
or     %ecx,%edx
mov    0x18(%rsp),%r12
add    %r12d,%r11d
add    %edx,%r11d
add    $0x5a827999,%r11d
rol    $0x3,%r11d
mov    %eax,%ecx
or     %r9d,%ecx
and    %r11d,%ecx
mov    %eax,%edx
and    %r9d,%edx
or     %ecx,%edx
mov    0xc(%rsp),%r13d
add    %r13d,%r10d
add    %edx,%r10d
add    $0x5a827999,%r10d
rol    $0x5,%r10d
mov    %r11d,%ecx
or     %eax,%ecx
and    %r10d,%ecx
mov    %r11d,%edx
and    %eax,%edx
or     %ecx,%edx
mov    0x3c(%rsp),%r15d
add    %r15d,%r9d
add    %edx,%r9d
add    $0x5a827999,%r9d
rol    $0x9,%r9d
mov    %r10d,%ecx
or     %r11d,%ecx
and    %r9d,%ecx
mov    %r10d,%edx
and    %r11d,%edx
or     %ecx,%edx
add    0x8(%rsp),%eax
lea    (%rdx,%rax,1),%ecx
add    $0x5a827999,%ecx
add    0x88(%rsp),%r11d
rol    $0xd,%ecx
mov    %r9d,%eax
xor    %r10d,%eax
xor    %ecx,%eax
add    %eax,%r11d
add    $0x6ed9eba1,%r11d
add    %ebx,%r10d
rol    $0x3,%r11d
mov    %r11d,%edx
xor    %ecx,%edx
mov    %edx,%eax
xor    %r9d,%eax
add    %r10d,%eax
add    $0x6ed9eba1,%eax
add    0x28(%rsp),%r9d
rol    $0x9,%eax
xor    %eax,%edx
lea    (%rdx,%r9,1),%ebx
add    $0x6ed9eba1,%ebx
add    %ebp,%ecx
rol    $0xb,%ebx
mov    %eax,%edx
xor    %r11d,%edx
xor    %ebx,%edx
add    %edx,%ecx
add    $0x6ed9eba1,%ecx
rol    $0xf,%ecx
add    %esi,%r11d
mov    %ebx,%edx
xor    %eax,%edx
xor    %ecx,%edx
lea    (%rdx,%r11,1),%esi
add    $0x6ed9eba1,%esi
rol    $0x3,%esi
add    %edi,%eax
mov    %ecx,%edx
xor    %ebx,%edx
xor    %esi,%edx
add    %eax,%edx
add    $0x6ed9eba1,%edx
rol    $0x9,%edx
add    %r8d,%ebx
mov    %esi,%eax
xor    %ecx,%eax
xor    %edx,%eax
add    %ebx,%eax
add    $0x6ed9eba1,%eax
rol    $0xb,%eax
add    %r14d,%ecx
mov    %edx,%edi
xor    %esi,%edi
xor    %eax,%edi
add    %edi,%ecx
add    $0x6ed9eba1,%ecx
rol    $0xf,%ecx
add    0x10(%rsp),%esi
mov    %eax,%edi
xor    %edx,%edi
xor    %ecx,%edi
add    %edi,%esi
add    $0x6ed9eba1,%esi
rol    $0x3,%esi
add    0x2c(%rsp),%edx
mov    %ecx,%edi
xor    %eax,%edi
xor    %esi,%edi
add    %edi,%edx
add    $0x6ed9eba1,%edx
rol    $0x9,%edx
add    0x38(%rsp),%eax
mov    %esi,%edi
xor    %ecx,%edi
xor    %edx,%edi
lea    (%rdi,%rax,1),%ebx
add    $0x6ed9eba1,%ebx
rol    $0xb,%ebx
mov    %edx,%eax
xor    %esi,%eax
xor    %ebx,%eax
add    0x30(%rsp),%ecx
add    %eax,%ecx
add    $0x6ed9eba1,%ecx
rol    $0xf,%ecx
mov    %ebx,%eax
xor    %edx,%eax
xor    %ecx,%eax
add    %r12d,%esi
lea    (%rax,%rsi,1),%ebp
add    $0x6ed9eba1,%ebp
rol    $0x3,%ebp
mov    %ecx,%eax
xor    %ebx,%eax
xor    %ebp,%eax
add    %r15d,%edx
lea    (%rax,%rdx,1),%r10d
add    $0x6ed9eba1,%r10d
rol    $0x9,%r10d
mov    %ebp,%edx
xor    %ecx,%edx
xor    %r10d,%edx
add    %r13d,%ebx
lea    (%rdx,%rbx,1),%r12d
add    $0x6ed9eba1,%r12d
rol    $0xb,%r12d
mov    %r10d,%esi
xor    %ebp,%esi
xor    %r12d,%esi
add    0x8(%rsp),%ecx
add    %ecx,%esi
add    $0x6ed9eba1,%esi
rol    $0xf,%esi
add    $0x67452301,%ebp
add    $0xefcdab89,%esi
add    $0x98badcfe,%r12d
add    $0x10325476,%r10d
mov    %ebp,%edi
and    $0xf,%edi
lea    0x8b6(%rip),%rcx
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x28ee(%rip)
mov    %ebp,%edi
shr    $0x4,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x28dc(%rip)
mov    %ebp,%edi
shr    $0x8,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x28ce(%rip)
mov    %ebp,%edi
shr    $0xc,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x28bc(%rip)
mov    %ebp,%edi
shr    $0x10,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x28ae(%rip)
mov    %ebp,%edi
shr    $0x14,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x289c(%rip)
mov    %ebp,%edi
shr    $0x18,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x288e(%rip)
shr    $0x1c,%rbp
mov    0x0(%rbp,%rcx,1),%bl
mov    %bl,0x287f(%rip)
mov    %esi,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x2874(%rip)
mov    %esi,%edi
shr    $0x4,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x2862(%rip)
mov    %esi,%edi
shr    $0x8,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x2854(%rip)
mov    %esi,%edi
shr    $0xc,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x2842(%rip)
mov    %esi,%edi
shr    $0x10,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x2834(%rip)
mov    %esi,%edi
shr    $0x14,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x2822(%rip)
mov    %esi,%edi
shr    $0x18,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%bl
mov    %bl,0x2814(%rip)
shr    $0x1c,%rsi
mov    (%rsi,%rcx,1),%al
mov    %al,0x10(%rsp)
mov    %r12d,%edi
and    $0xf,%edi
mov    (%rdi,%rcx,1),%al
mov    %al,0x8(%rsp)
mov    %r12d,%edx
shr    $0x4,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%al
mov    %al,0x18(%rsp)
mov    %r12d,%edx
shr    $0x8,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%al
mov    %al,0xc(%rsp)
mov    %r12d,%edx
shr    $0xc,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%dil
mov    %r12d,%edx
shr    $0x10,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%r11b
mov    %r12d,%edx
shr    $0x14,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%bpl
mov    %r12d,%edx
shr    $0x18,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%r14b
shr    $0x1c,%r12
mov    (%r12,%rcx,1),%r15b
mov    %r10d,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%r12b
mov    %r10d,%edx
shr    $0x4,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%r13b
mov    %r10d,%edx
shr    $0x8,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%sil
mov    %r10d,%edx
shr    $0xc,%edx
and    $0xf,%edx
mov    (%rdx,%rcx,1),%dl
mov    %r10d,%eax
shr    $0x10,%eax
and    $0xf,%eax
mov    (%rax,%rcx,1),%al
mov    %r10d,%r8d
shr    $0x14,%r8d
and    $0xf,%r8d
mov    (%r8,%rcx,1),%r8b
mov    %r10d,%r9d
shr    $0x18,%r9d
and    $0xf,%r9d
mov    (%r9,%rcx,1),%r9b
shr    $0x1c,%r10
mov    (%r10,%rcx,1),%cl
mov    0x10(%rsp),%bl
mov    %bl,0x2733(%rip)
mov    0x8(%rsp),%bl
mov    %bl,0x272c(%rip)
mov    0x18(%rsp),%bl
mov    %bl,0x2721(%rip)
mov    0xc(%rsp),%bl
mov    %bl,0x271a(%rip)
mov    %dil,0x2712(%rip)
mov    %r11b,0x270e(%rip)
mov    %bpl,0x2706(%rip)
mov    %r14b,0x2702(%rip)
mov    %r15b,0x26fa(%rip)
mov    %r12b,0x26f6(%rip)
mov    %r13b,0x26ee(%rip)
mov    %sil,0x26ea(%rip)
mov    %dl,0x26e3(%rip)
mov    %al,0x26e0(%rip)
mov    %r8b,0x26d8(%rip)
mov    %r9b,0x26d4(%rip)
mov    %cl,0x26cd(%rip)
lea    0x26a8(%rip),%rax
movb   $0x0,0x26c2(%rip)
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@ntlm_crypt.hex_format = internal global [33 x i8] zeroinitializer
@__const.ntlm_crypt.itoa16 = [16 x i8] c"0123456789abcdef"
define i8* @ntlm_crypt(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [16 x i32]
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [4 x i32]
%15 = alloca [16 x i8]
%16 = alloca i32
store i8* %0, i8** %2
%17 = load i8*, i8** %2
%18 = call i64 @strlen(i8* %17)
%19 = trunc i64 %18 to i32
store i32 %19, i32* %5
%20 = bitcast [16 x i8]* %15 to i8*
%21 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 0
%22 = bitcast i32* %21 to i8*
store i32 0, i32* %3
br label %23
23: ; preds = %49, %1
%24 = load i32, i32* %3
%25 = load i32, i32* %5
%26 = sdiv i32 %25, 2
%27 = icmp slt i32 %24, %26
br i1 %27, label %28, label %52
28: ; preds = %23
%29 = load i8*, i8** %2
%30 = load i32, i32* %3
%31 = mul nsw i32 2, %30
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8, i8* %29, i64 %32
%34 = load i8, i8* %33
%35 = sext i8 %34 to i32
%36 = load i8*, i8** %2
%37 = load i32, i32* %3
%38 = mul nsw i32 2, %37
%39 = add nsw i32 %38, 1
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %36, i64 %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = shl i32 %43, 16
%45 = or i32 %35, %44
%46 = load i32, i32* %3
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 %47
store i32 %45, i32* %48
br label %49
49: ; preds = %28
%50 = load i32, i32* %3
%51 = add nsw i32 %50, 1
store i32 %51, i32* %3
br label %23
52: ; preds = %23
%53 = load i32, i32* %5
%54 = srem i32 %53, 2
%55 = icmp eq i32 %54, 1
br i1 %55, label %56, label %68
56: ; preds = %52
%57 = load i8*, i8** %2
%58 = load i32, i32* %5
%59 = sub nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %57, i64 %60
%62 = load i8, i8* %61
%63 = sext i8 %62 to i32
%64 = or i32 %63, 8388608
%65 = load i32, i32* %3
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 %66
store i32 %64, i32* %67
br label %72
68: ; preds = %52
%69 = load i32, i32* %3
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 %70
store i32 128, i32* %71
br label %72
72: ; preds = %68, %56
%73 = load i32, i32* %5
%74 = shl i32 %73, 4
%75 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 14
store i32 %74, i32* %75
store i32 1732584193, i32* %7
%76 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 0
store i32 1732584193, i32* %76
store i32 -271733879, i32* %8
%77 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 1
store i32 -271733879, i32* %77
store i32 -1732584194, i32* %9
%78 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 2
store i32 -1732584194, i32* %78
store i32 271733878, i32* %10
%79 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 3
store i32 271733878, i32* %79
store i32 1518500249, i32* %11
store i32 1859775393, i32* %12
%80 = load i32, i32* %10
%81 = load i32, i32* %8
%82 = load i32, i32* %9
%83 = load i32, i32* %10
%84 = xor i32 %82, %83
%85 = and i32 %81, %84
%86 = xor i32 %80, %85
%87 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 0
%88 = load i32, i32* %87
%89 = add i32 %86, %88
%90 = load i32, i32* %7
%91 = add i32 %90, %89
store i32 %91, i32* %7
%92 = load i32, i32* %7
%93 = shl i32 %92, 3
%94 = load i32, i32* %7
%95 = lshr i32 %94, 29
%96 = or i32 %93, %95
store i32 %96, i32* %7
%97 = load i32, i32* %9
%98 = load i32, i32* %7
%99 = load i32, i32* %8
%100 = load i32, i32* %9
%101 = xor i32 %99, %100
%102 = and i32 %98, %101
%103 = xor i32 %97, %102
%104 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 1
%105 = load i32, i32* %104
%106 = add i32 %103, %105
%107 = load i32, i32* %10
%108 = add i32 %107, %106
store i32 %108, i32* %10
%109 = load i32, i32* %10
%110 = shl i32 %109, 7
%111 = load i32, i32* %10
%112 = lshr i32 %111, 25
%113 = or i32 %110, %112
store i32 %113, i32* %10
%114 = load i32, i32* %8
%115 = load i32, i32* %10
%116 = load i32, i32* %7
%117 = load i32, i32* %8
%118 = xor i32 %116, %117
%119 = and i32 %115, %118
%120 = xor i32 %114, %119
%121 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 2
%122 = load i32, i32* %121
%123 = add i32 %120, %122
%124 = load i32, i32* %9
%125 = add i32 %124, %123
store i32 %125, i32* %9
%126 = load i32, i32* %9
%127 = shl i32 %126, 11
%128 = load i32, i32* %9
%129 = lshr i32 %128, 21
%130 = or i32 %127, %129
store i32 %130, i32* %9
%131 = load i32, i32* %7
%132 = load i32, i32* %9
%133 = load i32, i32* %10
%134 = load i32, i32* %7
%135 = xor i32 %133, %134
%136 = and i32 %132, %135
%137 = xor i32 %131, %136
%138 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 3
%139 = load i32, i32* %138
%140 = add i32 %137, %139
%141 = load i32, i32* %8
%142 = add i32 %141, %140
store i32 %142, i32* %8
%143 = load i32, i32* %8
%144 = shl i32 %143, 19
%145 = load i32, i32* %8
%146 = lshr i32 %145, 13
%147 = or i32 %144, %146
store i32 %147, i32* %8
%148 = load i32, i32* %10
%149 = load i32, i32* %8
%150 = load i32, i32* %9
%151 = load i32, i32* %10
%152 = xor i32 %150, %151
%153 = and i32 %149, %152
%154 = xor i32 %148, %153
%155 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 4
%156 = load i32, i32* %155
%157 = add i32 %154, %156
%158 = load i32, i32* %7
%159 = add i32 %158, %157
store i32 %159, i32* %7
%160 = load i32, i32* %7
%161 = shl i32 %160, 3
%162 = load i32, i32* %7
%163 = lshr i32 %162, 29
%164 = or i32 %161, %163
store i32 %164, i32* %7
%165 = load i32, i32* %9
%166 = load i32, i32* %7
%167 = load i32, i32* %8
%168 = load i32, i32* %9
%169 = xor i32 %167, %168
%170 = and i32 %166, %169
%171 = xor i32 %165, %170
%172 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 5
%173 = load i32, i32* %172
%174 = add i32 %171, %173
%175 = load i32, i32* %10
%176 = add i32 %175, %174
store i32 %176, i32* %10
%177 = load i32, i32* %10
%178 = shl i32 %177, 7
%179 = load i32, i32* %10
%180 = lshr i32 %179, 25
%181 = or i32 %178, %180
store i32 %181, i32* %10
%182 = load i32, i32* %8
%183 = load i32, i32* %10
%184 = load i32, i32* %7
%185 = load i32, i32* %8
%186 = xor i32 %184, %185
%187 = and i32 %183, %186
%188 = xor i32 %182, %187
%189 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 6
%190 = load i32, i32* %189
%191 = add i32 %188, %190
%192 = load i32, i32* %9
%193 = add i32 %192, %191
store i32 %193, i32* %9
%194 = load i32, i32* %9
%195 = shl i32 %194, 11
%196 = load i32, i32* %9
%197 = lshr i32 %196, 21
%198 = or i32 %195, %197
store i32 %198, i32* %9
%199 = load i32, i32* %7
%200 = load i32, i32* %9
%201 = load i32, i32* %10
%202 = load i32, i32* %7
%203 = xor i32 %201, %202
%204 = and i32 %200, %203
%205 = xor i32 %199, %204
%206 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 7
%207 = load i32, i32* %206
%208 = add i32 %205, %207
%209 = load i32, i32* %8
%210 = add i32 %209, %208
store i32 %210, i32* %8
%211 = load i32, i32* %8
%212 = shl i32 %211, 19
%213 = load i32, i32* %8
%214 = lshr i32 %213, 13
%215 = or i32 %212, %214
store i32 %215, i32* %8
%216 = load i32, i32* %10
%217 = load i32, i32* %8
%218 = load i32, i32* %9
%219 = load i32, i32* %10
%220 = xor i32 %218, %219
%221 = and i32 %217, %220
%222 = xor i32 %216, %221
%223 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 8
%224 = load i32, i32* %223
%225 = add i32 %222, %224
%226 = load i32, i32* %7
%227 = add i32 %226, %225
store i32 %227, i32* %7
%228 = load i32, i32* %7
%229 = shl i32 %228, 3
%230 = load i32, i32* %7
%231 = lshr i32 %230, 29
%232 = or i32 %229, %231
store i32 %232, i32* %7
%233 = load i32, i32* %9
%234 = load i32, i32* %7
%235 = load i32, i32* %8
%236 = load i32, i32* %9
%237 = xor i32 %235, %236
%238 = and i32 %234, %237
%239 = xor i32 %233, %238
%240 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 9
%241 = load i32, i32* %240
%242 = add i32 %239, %241
%243 = load i32, i32* %10
%244 = add i32 %243, %242
store i32 %244, i32* %10
%245 = load i32, i32* %10
%246 = shl i32 %245, 7
%247 = load i32, i32* %10
%248 = lshr i32 %247, 25
%249 = or i32 %246, %248
store i32 %249, i32* %10
%250 = load i32, i32* %8
%251 = load i32, i32* %10
%252 = load i32, i32* %7
%253 = load i32, i32* %8
%254 = xor i32 %252, %253
%255 = and i32 %251, %254
%256 = xor i32 %250, %255
%257 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 10
%258 = load i32, i32* %257
%259 = add i32 %256, %258
%260 = load i32, i32* %9
%261 = add i32 %260, %259
store i32 %261, i32* %9
%262 = load i32, i32* %9
%263 = shl i32 %262, 11
%264 = load i32, i32* %9
%265 = lshr i32 %264, 21
%266 = or i32 %263, %265
store i32 %266, i32* %9
%267 = load i32, i32* %7
%268 = load i32, i32* %9
%269 = load i32, i32* %10
%270 = load i32, i32* %7
%271 = xor i32 %269, %270
%272 = and i32 %268, %271
%273 = xor i32 %267, %272
%274 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 11
%275 = load i32, i32* %274
%276 = add i32 %273, %275
%277 = load i32, i32* %8
%278 = add i32 %277, %276
store i32 %278, i32* %8
%279 = load i32, i32* %8
%280 = shl i32 %279, 19
%281 = load i32, i32* %8
%282 = lshr i32 %281, 13
%283 = or i32 %280, %282
store i32 %283, i32* %8
%284 = load i32, i32* %10
%285 = load i32, i32* %8
%286 = load i32, i32* %9
%287 = load i32, i32* %10
%288 = xor i32 %286, %287
%289 = and i32 %285, %288
%290 = xor i32 %284, %289
%291 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 12
%292 = load i32, i32* %291
%293 = add i32 %290, %292
%294 = load i32, i32* %7
%295 = add i32 %294, %293
store i32 %295, i32* %7
%296 = load i32, i32* %7
%297 = shl i32 %296, 3
%298 = load i32, i32* %7
%299 = lshr i32 %298, 29
%300 = or i32 %297, %299
store i32 %300, i32* %7
%301 = load i32, i32* %9
%302 = load i32, i32* %7
%303 = load i32, i32* %8
%304 = load i32, i32* %9
%305 = xor i32 %303, %304
%306 = and i32 %302, %305
%307 = xor i32 %301, %306
%308 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 13
%309 = load i32, i32* %308
%310 = add i32 %307, %309
%311 = load i32, i32* %10
%312 = add i32 %311, %310
store i32 %312, i32* %10
%313 = load i32, i32* %10
%314 = shl i32 %313, 7
%315 = load i32, i32* %10
%316 = lshr i32 %315, 25
%317 = or i32 %314, %316
store i32 %317, i32* %10
%318 = load i32, i32* %8
%319 = load i32, i32* %10
%320 = load i32, i32* %7
%321 = load i32, i32* %8
%322 = xor i32 %320, %321
%323 = and i32 %319, %322
%324 = xor i32 %318, %323
%325 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 14
%326 = load i32, i32* %325
%327 = add i32 %324, %326
%328 = load i32, i32* %9
%329 = add i32 %328, %327
store i32 %329, i32* %9
%330 = load i32, i32* %9
%331 = shl i32 %330, 11
%332 = load i32, i32* %9
%333 = lshr i32 %332, 21
%334 = or i32 %331, %333
store i32 %334, i32* %9
%335 = load i32, i32* %7
%336 = load i32, i32* %9
%337 = load i32, i32* %10
%338 = load i32, i32* %7
%339 = xor i32 %337, %338
%340 = and i32 %336, %339
%341 = xor i32 %335, %340
%342 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 15
%343 = load i32, i32* %342
%344 = add i32 %341, %343
%345 = load i32, i32* %8
%346 = add i32 %345, %344
store i32 %346, i32* %8
%347 = load i32, i32* %8
%348 = shl i32 %347, 19
%349 = load i32, i32* %8
%350 = lshr i32 %349, 13
%351 = or i32 %348, %350
store i32 %351, i32* %8
%352 = load i32, i32* %8
%353 = load i32, i32* %9
%354 = load i32, i32* %10
%355 = or i32 %353, %354
%356 = and i32 %352, %355
%357 = load i32, i32* %9
%358 = load i32, i32* %10
%359 = and i32 %357, %358
%360 = or i32 %356, %359
%361 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 0
%362 = load i32, i32* %361
%363 = add i32 %360, %362
%364 = load i32, i32* %11
%365 = add i32 %363, %364
%366 = load i32, i32* %7
%367 = add i32 %366, %365
store i32 %367, i32* %7
%368 = load i32, i32* %7
%369 = shl i32 %368, 3
%370 = load i32, i32* %7
%371 = lshr i32 %370, 29
%372 = or i32 %369, %371
store i32 %372, i32* %7
%373 = load i32, i32* %7
%374 = load i32, i32* %8
%375 = load i32, i32* %9
%376 = or i32 %374, %375
%377 = and i32 %373, %376
%378 = load i32, i32* %8
%379 = load i32, i32* %9
%380 = and i32 %378, %379
%381 = or i32 %377, %380
%382 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 4
%383 = load i32, i32* %382
%384 = add i32 %381, %383
%385 = load i32, i32* %11
%386 = add i32 %384, %385
%387 = load i32, i32* %10
%388 = add i32 %387, %386
store i32 %388, i32* %10
%389 = load i32, i32* %10
%390 = shl i32 %389, 5
%391 = load i32, i32* %10
%392 = lshr i32 %391, 27
%393 = or i32 %390, %392
store i32 %393, i32* %10
%394 = load i32, i32* %10
%395 = load i32, i32* %7
%396 = load i32, i32* %8
%397 = or i32 %395, %396
%398 = and i32 %394, %397
%399 = load i32, i32* %7
%400 = load i32, i32* %8
%401 = and i32 %399, %400
%402 = or i32 %398, %401
%403 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 8
%404 = load i32, i32* %403
%405 = add i32 %402, %404
%406 = load i32, i32* %11
%407 = add i32 %405, %406
%408 = load i32, i32* %9
%409 = add i32 %408, %407
store i32 %409, i32* %9
%410 = load i32, i32* %9
%411 = shl i32 %410, 9
%412 = load i32, i32* %9
%413 = lshr i32 %412, 23
%414 = or i32 %411, %413
store i32 %414, i32* %9
%415 = load i32, i32* %9
%416 = load i32, i32* %10
%417 = load i32, i32* %7
%418 = or i32 %416, %417
%419 = and i32 %415, %418
%420 = load i32, i32* %10
%421 = load i32, i32* %7
%422 = and i32 %420, %421
%423 = or i32 %419, %422
%424 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 12
%425 = load i32, i32* %424
%426 = add i32 %423, %425
%427 = load i32, i32* %11
%428 = add i32 %426, %427
%429 = load i32, i32* %8
%430 = add i32 %429, %428
store i32 %430, i32* %8
%431 = load i32, i32* %8
%432 = shl i32 %431, 13
%433 = load i32, i32* %8
%434 = lshr i32 %433, 19
%435 = or i32 %432, %434
store i32 %435, i32* %8
%436 = load i32, i32* %8
%437 = load i32, i32* %9
%438 = load i32, i32* %10
%439 = or i32 %437, %438
%440 = and i32 %436, %439
%441 = load i32, i32* %9
%442 = load i32, i32* %10
%443 = and i32 %441, %442
%444 = or i32 %440, %443
%445 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 1
%446 = load i32, i32* %445
%447 = add i32 %444, %446
%448 = load i32, i32* %11
%449 = add i32 %447, %448
%450 = load i32, i32* %7
%451 = add i32 %450, %449
store i32 %451, i32* %7
%452 = load i32, i32* %7
%453 = shl i32 %452, 3
%454 = load i32, i32* %7
%455 = lshr i32 %454, 29
%456 = or i32 %453, %455
store i32 %456, i32* %7
%457 = load i32, i32* %7
%458 = load i32, i32* %8
%459 = load i32, i32* %9
%460 = or i32 %458, %459
%461 = and i32 %457, %460
%462 = load i32, i32* %8
%463 = load i32, i32* %9
%464 = and i32 %462, %463
%465 = or i32 %461, %464
%466 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 5
%467 = load i32, i32* %466
%468 = add i32 %465, %467
%469 = load i32, i32* %11
%470 = add i32 %468, %469
%471 = load i32, i32* %10
%472 = add i32 %471, %470
store i32 %472, i32* %10
%473 = load i32, i32* %10
%474 = shl i32 %473, 5
%475 = load i32, i32* %10
%476 = lshr i32 %475, 27
%477 = or i32 %474, %476
store i32 %477, i32* %10
%478 = load i32, i32* %10
%479 = load i32, i32* %7
%480 = load i32, i32* %8
%481 = or i32 %479, %480
%482 = and i32 %478, %481
%483 = load i32, i32* %7
%484 = load i32, i32* %8
%485 = and i32 %483, %484
%486 = or i32 %482, %485
%487 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 9
%488 = load i32, i32* %487
%489 = add i32 %486, %488
%490 = load i32, i32* %11
%491 = add i32 %489, %490
%492 = load i32, i32* %9
%493 = add i32 %492, %491
store i32 %493, i32* %9
%494 = load i32, i32* %9
%495 = shl i32 %494, 9
%496 = load i32, i32* %9
%497 = lshr i32 %496, 23
%498 = or i32 %495, %497
store i32 %498, i32* %9
%499 = load i32, i32* %9
%500 = load i32, i32* %10
%501 = load i32, i32* %7
%502 = or i32 %500, %501
%503 = and i32 %499, %502
%504 = load i32, i32* %10
%505 = load i32, i32* %7
%506 = and i32 %504, %505
%507 = or i32 %503, %506
%508 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 13
%509 = load i32, i32* %508
%510 = add i32 %507, %509
%511 = load i32, i32* %11
%512 = add i32 %510, %511
%513 = load i32, i32* %8
%514 = add i32 %513, %512
store i32 %514, i32* %8
%515 = load i32, i32* %8
%516 = shl i32 %515, 13
%517 = load i32, i32* %8
%518 = lshr i32 %517, 19
%519 = or i32 %516, %518
store i32 %519, i32* %8
%520 = load i32, i32* %8
%521 = load i32, i32* %9
%522 = load i32, i32* %10
%523 = or i32 %521, %522
%524 = and i32 %520, %523
%525 = load i32, i32* %9
%526 = load i32, i32* %10
%527 = and i32 %525, %526
%528 = or i32 %524, %527
%529 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 2
%530 = load i32, i32* %529
%531 = add i32 %528, %530
%532 = load i32, i32* %11
%533 = add i32 %531, %532
%534 = load i32, i32* %7
%535 = add i32 %534, %533
store i32 %535, i32* %7
%536 = load i32, i32* %7
%537 = shl i32 %536, 3
%538 = load i32, i32* %7
%539 = lshr i32 %538, 29
%540 = or i32 %537, %539
store i32 %540, i32* %7
%541 = load i32, i32* %7
%542 = load i32, i32* %8
%543 = load i32, i32* %9
%544 = or i32 %542, %543
%545 = and i32 %541, %544
%546 = load i32, i32* %8
%547 = load i32, i32* %9
%548 = and i32 %546, %547
%549 = or i32 %545, %548
%550 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 6
%551 = load i32, i32* %550
%552 = add i32 %549, %551
%553 = load i32, i32* %11
%554 = add i32 %552, %553
%555 = load i32, i32* %10
%556 = add i32 %555, %554
store i32 %556, i32* %10
%557 = load i32, i32* %10
%558 = shl i32 %557, 5
%559 = load i32, i32* %10
%560 = lshr i32 %559, 27
%561 = or i32 %558, %560
store i32 %561, i32* %10
%562 = load i32, i32* %10
%563 = load i32, i32* %7
%564 = load i32, i32* %8
%565 = or i32 %563, %564
%566 = and i32 %562, %565
%567 = load i32, i32* %7
%568 = load i32, i32* %8
%569 = and i32 %567, %568
%570 = or i32 %566, %569
%571 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 10
%572 = load i32, i32* %571
%573 = add i32 %570, %572
%574 = load i32, i32* %11
%575 = add i32 %573, %574
%576 = load i32, i32* %9
%577 = add i32 %576, %575
store i32 %577, i32* %9
%578 = load i32, i32* %9
%579 = shl i32 %578, 9
%580 = load i32, i32* %9
%581 = lshr i32 %580, 23
%582 = or i32 %579, %581
store i32 %582, i32* %9
%583 = load i32, i32* %9
%584 = load i32, i32* %10
%585 = load i32, i32* %7
%586 = or i32 %584, %585
%587 = and i32 %583, %586
%588 = load i32, i32* %10
%589 = load i32, i32* %7
%590 = and i32 %588, %589
%591 = or i32 %587, %590
%592 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 14
%593 = load i32, i32* %592
%594 = add i32 %591, %593
%595 = load i32, i32* %11
%596 = add i32 %594, %595
%597 = load i32, i32* %8
%598 = add i32 %597, %596
store i32 %598, i32* %8
%599 = load i32, i32* %8
%600 = shl i32 %599, 13
%601 = load i32, i32* %8
%602 = lshr i32 %601, 19
%603 = or i32 %600, %602
store i32 %603, i32* %8
%604 = load i32, i32* %8
%605 = load i32, i32* %9
%606 = load i32, i32* %10
%607 = or i32 %605, %606
%608 = and i32 %604, %607
%609 = load i32, i32* %9
%610 = load i32, i32* %10
%611 = and i32 %609, %610
%612 = or i32 %608, %611
%613 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 3
%614 = load i32, i32* %613
%615 = add i32 %612, %614
%616 = load i32, i32* %11
%617 = add i32 %615, %616
%618 = load i32, i32* %7
%619 = add i32 %618, %617
store i32 %619, i32* %7
%620 = load i32, i32* %7
%621 = shl i32 %620, 3
%622 = load i32, i32* %7
%623 = lshr i32 %622, 29
%624 = or i32 %621, %623
store i32 %624, i32* %7
%625 = load i32, i32* %7
%626 = load i32, i32* %8
%627 = load i32, i32* %9
%628 = or i32 %626, %627
%629 = and i32 %625, %628
%630 = load i32, i32* %8
%631 = load i32, i32* %9
%632 = and i32 %630, %631
%633 = or i32 %629, %632
%634 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 7
%635 = load i32, i32* %634
%636 = add i32 %633, %635
%637 = load i32, i32* %11
%638 = add i32 %636, %637
%639 = load i32, i32* %10
%640 = add i32 %639, %638
store i32 %640, i32* %10
%641 = load i32, i32* %10
%642 = shl i32 %641, 5
%643 = load i32, i32* %10
%644 = lshr i32 %643, 27
%645 = or i32 %642, %644
store i32 %645, i32* %10
%646 = load i32, i32* %10
%647 = load i32, i32* %7
%648 = load i32, i32* %8
%649 = or i32 %647, %648
%650 = and i32 %646, %649
%651 = load i32, i32* %7
%652 = load i32, i32* %8
%653 = and i32 %651, %652
%654 = or i32 %650, %653
%655 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 11
%656 = load i32, i32* %655
%657 = add i32 %654, %656
%658 = load i32, i32* %11
%659 = add i32 %657, %658
%660 = load i32, i32* %9
%661 = add i32 %660, %659
store i32 %661, i32* %9
%662 = load i32, i32* %9
%663 = shl i32 %662, 9
%664 = load i32, i32* %9
%665 = lshr i32 %664, 23
%666 = or i32 %663, %665
store i32 %666, i32* %9
%667 = load i32, i32* %9
%668 = load i32, i32* %10
%669 = load i32, i32* %7
%670 = or i32 %668, %669
%671 = and i32 %667, %670
%672 = load i32, i32* %10
%673 = load i32, i32* %7
%674 = and i32 %672, %673
%675 = or i32 %671, %674
%676 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 15
%677 = load i32, i32* %676
%678 = add i32 %675, %677
%679 = load i32, i32* %11
%680 = add i32 %678, %679
%681 = load i32, i32* %8
%682 = add i32 %681, %680
store i32 %682, i32* %8
%683 = load i32, i32* %8
%684 = shl i32 %683, 13
%685 = load i32, i32* %8
%686 = lshr i32 %685, 19
%687 = or i32 %684, %686
store i32 %687, i32* %8
%688 = load i32, i32* %10
%689 = load i32, i32* %9
%690 = xor i32 %688, %689
%691 = load i32, i32* %8
%692 = xor i32 %690, %691
%693 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 0
%694 = load i32, i32* %693
%695 = add i32 %692, %694
%696 = load i32, i32* %12
%697 = add i32 %695, %696
%698 = load i32, i32* %7
%699 = add i32 %698, %697
store i32 %699, i32* %7
%700 = load i32, i32* %7
%701 = shl i32 %700, 3
%702 = load i32, i32* %7
%703 = lshr i32 %702, 29
%704 = or i32 %701, %703
store i32 %704, i32* %7
%705 = load i32, i32* %9
%706 = load i32, i32* %8
%707 = xor i32 %705, %706
%708 = load i32, i32* %7
%709 = xor i32 %707, %708
%710 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 8
%711 = load i32, i32* %710
%712 = add i32 %709, %711
%713 = load i32, i32* %12
%714 = add i32 %712, %713
%715 = load i32, i32* %10
%716 = add i32 %715, %714
store i32 %716, i32* %10
%717 = load i32, i32* %10
%718 = shl i32 %717, 9
%719 = load i32, i32* %10
%720 = lshr i32 %719, 23
%721 = or i32 %718, %720
store i32 %721, i32* %10
%722 = load i32, i32* %8
%723 = load i32, i32* %7
%724 = xor i32 %722, %723
%725 = load i32, i32* %10
%726 = xor i32 %724, %725
%727 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 4
%728 = load i32, i32* %727
%729 = add i32 %726, %728
%730 = load i32, i32* %12
%731 = add i32 %729, %730
%732 = load i32, i32* %9
%733 = add i32 %732, %731
store i32 %733, i32* %9
%734 = load i32, i32* %9
%735 = shl i32 %734, 11
%736 = load i32, i32* %9
%737 = lshr i32 %736, 21
%738 = or i32 %735, %737
store i32 %738, i32* %9
%739 = load i32, i32* %7
%740 = load i32, i32* %10
%741 = xor i32 %739, %740
%742 = load i32, i32* %9
%743 = xor i32 %741, %742
%744 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 12
%745 = load i32, i32* %744
%746 = add i32 %743, %745
%747 = load i32, i32* %12
%748 = add i32 %746, %747
%749 = load i32, i32* %8
%750 = add i32 %749, %748
store i32 %750, i32* %8
%751 = load i32, i32* %8
%752 = shl i32 %751, 15
%753 = load i32, i32* %8
%754 = lshr i32 %753, 17
%755 = or i32 %752, %754
store i32 %755, i32* %8
%756 = load i32, i32* %10
%757 = load i32, i32* %9
%758 = xor i32 %756, %757
%759 = load i32, i32* %8
%760 = xor i32 %758, %759
%761 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 2
%762 = load i32, i32* %761
%763 = add i32 %760, %762
%764 = load i32, i32* %12
%765 = add i32 %763, %764
%766 = load i32, i32* %7
%767 = add i32 %766, %765
store i32 %767, i32* %7
%768 = load i32, i32* %7
%769 = shl i32 %768, 3
%770 = load i32, i32* %7
%771 = lshr i32 %770, 29
%772 = or i32 %769, %771
store i32 %772, i32* %7
%773 = load i32, i32* %9
%774 = load i32, i32* %8
%775 = xor i32 %773, %774
%776 = load i32, i32* %7
%777 = xor i32 %775, %776
%778 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 10
%779 = load i32, i32* %778
%780 = add i32 %777, %779
%781 = load i32, i32* %12
%782 = add i32 %780, %781
%783 = load i32, i32* %10
%784 = add i32 %783, %782
store i32 %784, i32* %10
%785 = load i32, i32* %10
%786 = shl i32 %785, 9
%787 = load i32, i32* %10
%788 = lshr i32 %787, 23
%789 = or i32 %786, %788
store i32 %789, i32* %10
%790 = load i32, i32* %8
%791 = load i32, i32* %7
%792 = xor i32 %790, %791
%793 = load i32, i32* %10
%794 = xor i32 %792, %793
%795 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 6
%796 = load i32, i32* %795
%797 = add i32 %794, %796
%798 = load i32, i32* %12
%799 = add i32 %797, %798
%800 = load i32, i32* %9
%801 = add i32 %800, %799
store i32 %801, i32* %9
%802 = load i32, i32* %9
%803 = shl i32 %802, 11
%804 = load i32, i32* %9
%805 = lshr i32 %804, 21
%806 = or i32 %803, %805
store i32 %806, i32* %9
%807 = load i32, i32* %7
%808 = load i32, i32* %10
%809 = xor i32 %807, %808
%810 = load i32, i32* %9
%811 = xor i32 %809, %810
%812 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 14
%813 = load i32, i32* %812
%814 = add i32 %811, %813
%815 = load i32, i32* %12
%816 = add i32 %814, %815
%817 = load i32, i32* %8
%818 = add i32 %817, %816
store i32 %818, i32* %8
%819 = load i32, i32* %8
%820 = shl i32 %819, 15
%821 = load i32, i32* %8
%822 = lshr i32 %821, 17
%823 = or i32 %820, %822
store i32 %823, i32* %8
%824 = load i32, i32* %10
%825 = load i32, i32* %9
%826 = xor i32 %824, %825
%827 = load i32, i32* %8
%828 = xor i32 %826, %827
%829 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 1
%830 = load i32, i32* %829
%831 = add i32 %828, %830
%832 = load i32, i32* %12
%833 = add i32 %831, %832
%834 = load i32, i32* %7
%835 = add i32 %834, %833
store i32 %835, i32* %7
%836 = load i32, i32* %7
%837 = shl i32 %836, 3
%838 = load i32, i32* %7
%839 = lshr i32 %838, 29
%840 = or i32 %837, %839
store i32 %840, i32* %7
%841 = load i32, i32* %9
%842 = load i32, i32* %8
%843 = xor i32 %841, %842
%844 = load i32, i32* %7
%845 = xor i32 %843, %844
%846 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 9
%847 = load i32, i32* %846
%848 = add i32 %845, %847
%849 = load i32, i32* %12
%850 = add i32 %848, %849
%851 = load i32, i32* %10
%852 = add i32 %851, %850
store i32 %852, i32* %10
%853 = load i32, i32* %10
%854 = shl i32 %853, 9
%855 = load i32, i32* %10
%856 = lshr i32 %855, 23
%857 = or i32 %854, %856
store i32 %857, i32* %10
%858 = load i32, i32* %8
%859 = load i32, i32* %7
%860 = xor i32 %858, %859
%861 = load i32, i32* %10
%862 = xor i32 %860, %861
%863 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 5
%864 = load i32, i32* %863
%865 = add i32 %862, %864
%866 = load i32, i32* %12
%867 = add i32 %865, %866
%868 = load i32, i32* %9
%869 = add i32 %868, %867
store i32 %869, i32* %9
%870 = load i32, i32* %9
%871 = shl i32 %870, 11
%872 = load i32, i32* %9
%873 = lshr i32 %872, 21
%874 = or i32 %871, %873
store i32 %874, i32* %9
%875 = load i32, i32* %7
%876 = load i32, i32* %10
%877 = xor i32 %875, %876
%878 = load i32, i32* %9
%879 = xor i32 %877, %878
%880 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 13
%881 = load i32, i32* %880
%882 = add i32 %879, %881
%883 = load i32, i32* %12
%884 = add i32 %882, %883
%885 = load i32, i32* %8
%886 = add i32 %885, %884
store i32 %886, i32* %8
%887 = load i32, i32* %8
%888 = shl i32 %887, 15
%889 = load i32, i32* %8
%890 = lshr i32 %889, 17
%891 = or i32 %888, %890
store i32 %891, i32* %8
%892 = load i32, i32* %10
%893 = load i32, i32* %9
%894 = xor i32 %892, %893
%895 = load i32, i32* %8
%896 = xor i32 %894, %895
%897 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 3
%898 = load i32, i32* %897
%899 = add i32 %896, %898
%900 = load i32, i32* %12
%901 = add i32 %899, %900
%902 = load i32, i32* %7
%903 = add i32 %902, %901
store i32 %903, i32* %7
%904 = load i32, i32* %7
%905 = shl i32 %904, 3
%906 = load i32, i32* %7
%907 = lshr i32 %906, 29
%908 = or i32 %905, %907
store i32 %908, i32* %7
%909 = load i32, i32* %9
%910 = load i32, i32* %8
%911 = xor i32 %909, %910
%912 = load i32, i32* %7
%913 = xor i32 %911, %912
%914 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 11
%915 = load i32, i32* %914
%916 = add i32 %913, %915
%917 = load i32, i32* %12
%918 = add i32 %916, %917
%919 = load i32, i32* %10
%920 = add i32 %919, %918
store i32 %920, i32* %10
%921 = load i32, i32* %10
%922 = shl i32 %921, 9
%923 = load i32, i32* %10
%924 = lshr i32 %923, 23
%925 = or i32 %922, %924
store i32 %925, i32* %10
%926 = load i32, i32* %8
%927 = load i32, i32* %7
%928 = xor i32 %926, %927
%929 = load i32, i32* %10
%930 = xor i32 %928, %929
%931 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 7
%932 = load i32, i32* %931
%933 = add i32 %930, %932
%934 = load i32, i32* %12
%935 = add i32 %933, %934
%936 = load i32, i32* %9
%937 = add i32 %936, %935
store i32 %937, i32* %9
%938 = load i32, i32* %9
%939 = shl i32 %938, 11
%940 = load i32, i32* %9
%941 = lshr i32 %940, 21
%942 = or i32 %939, %941
store i32 %942, i32* %9
%943 = load i32, i32* %7
%944 = load i32, i32* %10
%945 = xor i32 %943, %944
%946 = load i32, i32* %9
%947 = xor i32 %945, %946
%948 = getelementptr inbounds [16 x i32], [16 x i32]* %6, i64 0, i64 15
%949 = load i32, i32* %948
%950 = add i32 %947, %949
%951 = load i32, i32* %12
%952 = add i32 %950, %951
%953 = load i32, i32* %8
%954 = add i32 %953, %952
store i32 %954, i32* %8
%955 = load i32, i32* %8
%956 = shl i32 %955, 15
%957 = load i32, i32* %8
%958 = lshr i32 %957, 17
%959 = or i32 %956, %958
store i32 %959, i32* %8
%960 = load i32, i32* %7
%961 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 0
%962 = load i32, i32* %961
%963 = add i32 %962, %960
store i32 %963, i32* %961
%964 = load i32, i32* %8
%965 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 1
%966 = load i32, i32* %965
%967 = add i32 %966, %964
store i32 %967, i32* %965
%968 = load i32, i32* %9
%969 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 2
%970 = load i32, i32* %969
%971 = add i32 %970, %968
store i32 %971, i32* %969
%972 = load i32, i32* %10
%973 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 3
%974 = load i32, i32* %973
%975 = add i32 %974, %972
store i32 %975, i32* %973
store i32 0, i32* %3
br label %976
976: ; preds = %1024, %72
%977 = load i32, i32* %3
%978 = icmp slt i32 %977, 4
br i1 %978, label %979, label %1027
979: ; preds = %976
store i32 0, i32* %4
%980 = load i32, i32* %3
%981 = sext i32 %980 to i64
%982 = getelementptr inbounds [4 x i32], [4 x i32]* %14, i64 0, i64 %981
%983 = load i32, i32* %982
store i32 %983, i32* %13
br label %984
984: ; preds = %1020, %979
%985 = load i32, i32* %4
%986 = icmp slt i32 %985, 4
br i1 %986, label %987, label %1023
987: ; preds = %984
%988 = load i32, i32* %13
%989 = urem i32 %988, 256
store i32 %989, i32* %16
%990 = load i32, i32* %16
%991 = urem i32 %990, 16
%992 = zext i32 %991 to i64
%993 = getelementptr inbounds [16 x i8], [16 x i8]* %15, i64 0, i64 %992
%994 = load i8, i8* %993
%995 = load i32, i32* %3
%996 = mul nsw i32 %995, 8
%997 = load i32, i32* %4
%998 = mul nsw i32 %997, 2
%999 = add nsw i32 %996, %998
%1000 = add nsw i32 %999, 1
%1001 = sext i32 %1000 to i64
%1002 = getelementptr inbounds [33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 %1001
store i8 %994, i8* %1002
%1003 = load i32, i32* %16
%1004 = udiv i32 %1003, 16
store i32 %1004, i32* %16
%1005 = load i32, i32* %16
%1006 = urem i32 %1005, 16
%1007 = zext i32 %1006 to i64
%1008 = getelementptr inbounds [16 x i8], [16 x i8]* %15, i64 0, i64 %1007
%1009 = load i8, i8* %1008
%1010 = load i32, i32* %3
%1011 = mul nsw i32 %1010, 8
%1012 = load i32, i32* %4
%1013 = mul nsw i32 %1012, 2
%1014 = add nsw i32 %1011, %1013
%1015 = add nsw i32 %1014, 0
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds [33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 %1016
store i8 %1009, i8* %1017
%1018 = load i32, i32* %13
%1019 = udiv i32 %1018, 256
store i32 %1019, i32* %13
br label %1020
1020: ; preds = %987
%1021 = load i32, i32* %4
%1022 = add nsw i32 %1021, 1
store i32 %1022, i32* %4
br label %984
1023: ; preds = %984
br label %1024
1024: ; preds = %1023
%1025 = load i32, i32* %3
%1026 = add nsw i32 %1025, 1
store i32 %1026, i32* %3
br label %976
1027: ; preds = %976
store i8 0, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 1, i64 0)
ret i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 0)
}

LLVM IR (-O2):
@ntlm_crypt.hex_format = internal global [33 x i8] zeroinitializer
@__const.ntlm_crypt.itoa16 = [16 x i8] c"0123456789abcdef"
define i8* @ntlm_crypt(i8* nocapture %0) {
%2 = alloca [16 x i32]
%3 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%4 = trunc i64 %3 to i32
%5 = bitcast [16 x i32]* %2 to i8*
%6 = sdiv i32 %4, 2
%7 = srem i32 %4, 2
%8 = icmp sgt i32 %4, 1
br i1 %8, label %9, label %62
9: ; preds = %1
%10 = zext i32 %6 to i64
%11 = and i64 %10, 1
%12 = and i32 %4, -2
%13 = icmp eq i32 %12, 2
br i1 %13, label %45, label %14
14: ; preds = %9
%15 = and i64 %10, 4294967294
br label %16
16: ; preds = %16, %14
%17 = phi i64 [ 0, %14 ], [ %42, %16 ]
%18 = phi i64 [ 0, %14 ], [ %43, %16 ]
%19 = shl nuw nsw i64 %17, 1
%20 = getelementptr inbounds i8, i8* %0, i64 %19
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = or i64 %19, 1
%24 = getelementptr inbounds i8, i8* %0, i64 %23
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = shl nsw i32 %26, 16
%28 = or i32 %27, %22
%29 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %17
store i32 %28, i32* %29
%30 = or i64 %17, 1
%31 = shl nuw nsw i64 %30, 1
%32 = getelementptr inbounds i8, i8* %0, i64 %31
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = or i64 %31, 1
%36 = getelementptr inbounds i8, i8* %0, i64 %35
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = shl nsw i32 %38, 16
%40 = or i32 %39, %34
%41 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %30
store i32 %40, i32* %41
%42 = add nuw nsw i64 %17, 2
%43 = add nuw i64 %18, 2
%44 = icmp eq i64 %43, %15
br i1 %44, label %45, label %16
45: ; preds = %16, %9
%46 = phi i64 [ 0, %9 ], [ %42, %16 ]
%47 = icmp eq i64 %11, 0
br i1 %47, label %60, label %48
48: ; preds = %45
%49 = shl nuw nsw i64 %46, 1
%50 = getelementptr inbounds i8, i8* %0, i64 %49
%51 = load i8, i8* %50
%52 = sext i8 %51 to i32
%53 = or i64 %49, 1
%54 = getelementptr inbounds i8, i8* %0, i64 %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = shl nsw i32 %56, 16
%58 = or i32 %57, %52
%59 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %46
store i32 %58, i32* %59
br label %60
60: ; preds = %45, %48
%61 = zext i32 %6 to i64
br label %62
62: ; preds = %60, %1
%63 = phi i64 [ 0, %1 ], [ %61, %60 ]
%64 = icmp eq i32 %7, 1
br i1 %64, label %65, label %73
65: ; preds = %62
%66 = shl i64 %3, 32
%67 = add i64 %66, -4294967296
%68 = ashr exact i64 %67, 32
%69 = getelementptr inbounds i8, i8* %0, i64 %68
%70 = load i8, i8* %69
%71 = sext i8 %70 to i32
%72 = or i32 %71, 8388608
br label %73
73: ; preds = %62, %65
%74 = phi i32 [ %72, %65 ], [ 128, %62 ]
%75 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %63
store i32 %74, i32* %75
%76 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%77 = shl i32 %4, 4
%78 = load i32, i32* %76
%79 = add i32 %78, -1
%80 = tail call i32 @llvm.fshl.i32(i32 %79, i32 %79, i32 3)
%81 = and i32 %80, 2004318071
%82 = xor i32 %81, -1732584194
%83 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 1
%84 = load i32, i32* %83
%85 = add i32 %84, 271733878
%86 = add i32 %85, %82
%87 = tail call i32 @llvm.fshl.i32(i32 %86, i32 %86, i32 7)
%88 = xor i32 %80, -271733879
%89 = and i32 %87, %88
%90 = xor i32 %89, -271733879
%91 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 2
%92 = load i32, i32* %91
%93 = add i32 %92, -1732584194
%94 = add i32 %93, %90
%95 = tail call i32 @llvm.fshl.i32(i32 %94, i32 %94, i32 11)
%96 = xor i32 %87, %80
%97 = and i32 %95, %96
%98 = xor i32 %97, %80
%99 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 3
%100 = load i32, i32* %99
%101 = add i32 %100, -271733879
%102 = add i32 %101, %98
%103 = tail call i32 @llvm.fshl.i32(i32 %102, i32 %102, i32 19)
%104 = xor i32 %95, %87
%105 = and i32 %103, %104
%106 = xor i32 %105, %87
%107 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 4
%108 = load i32, i32* %107
%109 = add i32 %108, %80
%110 = add i32 %109, %106
%111 = tail call i32 @llvm.fshl.i32(i32 %110, i32 %110, i32 3)
%112 = xor i32 %103, %95
%113 = and i32 %111, %112
%114 = xor i32 %113, %95
%115 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 5
%116 = load i32, i32* %115
%117 = add i32 %87, %116
%118 = add i32 %117, %114
%119 = tail call i32 @llvm.fshl.i32(i32 %118, i32 %118, i32 7)
%120 = xor i32 %111, %103
%121 = and i32 %119, %120
%122 = xor i32 %121, %103
%123 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 6
%124 = load i32, i32* %123
%125 = add i32 %95, %124
%126 = add i32 %125, %122
%127 = tail call i32 @llvm.fshl.i32(i32 %126, i32 %126, i32 11)
%128 = xor i32 %119, %111
%129 = and i32 %127, %128
%130 = xor i32 %129, %111
%131 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 7
%132 = load i32, i32* %131
%133 = add i32 %103, %132
%134 = add i32 %133, %130
%135 = tail call i32 @llvm.fshl.i32(i32 %134, i32 %134, i32 19)
%136 = xor i32 %127, %119
%137 = and i32 %135, %136
%138 = xor i32 %137, %119
%139 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 8
%140 = load i32, i32* %139
%141 = add i32 %111, %140
%142 = add i32 %141, %138
%143 = tail call i32 @llvm.fshl.i32(i32 %142, i32 %142, i32 3)
%144 = xor i32 %135, %127
%145 = and i32 %143, %144
%146 = xor i32 %145, %127
%147 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 9
%148 = load i32, i32* %147
%149 = add i32 %119, %148
%150 = add i32 %149, %146
%151 = tail call i32 @llvm.fshl.i32(i32 %150, i32 %150, i32 7)
%152 = xor i32 %143, %135
%153 = and i32 %151, %152
%154 = xor i32 %153, %135
%155 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 10
%156 = load i32, i32* %155
%157 = add i32 %127, %156
%158 = add i32 %157, %154
%159 = tail call i32 @llvm.fshl.i32(i32 %158, i32 %158, i32 11)
%160 = xor i32 %151, %143
%161 = and i32 %159, %160
%162 = xor i32 %161, %143
%163 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 11
%164 = load i32, i32* %163
%165 = add i32 %135, %164
%166 = add i32 %165, %162
%167 = tail call i32 @llvm.fshl.i32(i32 %166, i32 %166, i32 19)
%168 = xor i32 %159, %151
%169 = and i32 %167, %168
%170 = xor i32 %169, %151
%171 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 12
%172 = load i32, i32* %171
%173 = add i32 %143, %172
%174 = add i32 %173, %170
%175 = tail call i32 @llvm.fshl.i32(i32 %174, i32 %174, i32 3)
%176 = xor i32 %167, %159
%177 = and i32 %175, %176
%178 = xor i32 %177, %159
%179 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 13
%180 = load i32, i32* %179
%181 = add i32 %151, %180
%182 = add i32 %181, %178
%183 = tail call i32 @llvm.fshl.i32(i32 %182, i32 %182, i32 7)
%184 = xor i32 %175, %167
%185 = and i32 %183, %184
%186 = xor i32 %185, %167
%187 = add i32 %159, %77
%188 = add i32 %187, %186
%189 = tail call i32 @llvm.fshl.i32(i32 %188, i32 %188, i32 11)
%190 = xor i32 %183, %175
%191 = and i32 %189, %190
%192 = xor i32 %191, %175
%193 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 15
%194 = load i32, i32* %193
%195 = add i32 %167, %194
%196 = add i32 %195, %192
%197 = tail call i32 @llvm.fshl.i32(i32 %196, i32 %196, i32 19)
%198 = or i32 %189, %183
%199 = and i32 %197, %198
%200 = and i32 %189, %183
%201 = or i32 %199, %200
%202 = add i32 %78, 1518500249
%203 = add i32 %202, %175
%204 = add i32 %203, %201
%205 = tail call i32 @llvm.fshl.i32(i32 %204, i32 %204, i32 3)
%206 = or i32 %197, %189
%207 = and i32 %205, %206
%208 = and i32 %197, %189
%209 = or i32 %207, %208
%210 = add i32 %108, 1518500249
%211 = add i32 %210, %183
%212 = add i32 %211, %209
%213 = tail call i32 @llvm.fshl.i32(i32 %212, i32 %212, i32 5)
%214 = or i32 %205, %197
%215 = and i32 %213, %214
%216 = and i32 %205, %197
%217 = or i32 %215, %216
%218 = add i32 %140, 1518500249
%219 = add i32 %218, %189
%220 = add i32 %219, %217
%221 = tail call i32 @llvm.fshl.i32(i32 %220, i32 %220, i32 9)
%222 = or i32 %213, %205
%223 = and i32 %221, %222
%224 = and i32 %213, %205
%225 = or i32 %223, %224
%226 = add i32 %172, 1518500249
%227 = add i32 %226, %197
%228 = add i32 %227, %225
%229 = tail call i32 @llvm.fshl.i32(i32 %228, i32 %228, i32 13)
%230 = or i32 %221, %213
%231 = and i32 %229, %230
%232 = and i32 %221, %213
%233 = or i32 %231, %232
%234 = add i32 %84, 1518500249
%235 = add i32 %234, %205
%236 = add i32 %235, %233
%237 = tail call i32 @llvm.fshl.i32(i32 %236, i32 %236, i32 3)
%238 = or i32 %229, %221
%239 = and i32 %237, %238
%240 = and i32 %229, %221
%241 = or i32 %239, %240
%242 = add i32 %116, 1518500249
%243 = add i32 %242, %213
%244 = add i32 %243, %241
%245 = tail call i32 @llvm.fshl.i32(i32 %244, i32 %244, i32 5)
%246 = or i32 %237, %229
%247 = and i32 %245, %246
%248 = and i32 %237, %229
%249 = or i32 %247, %248
%250 = add i32 %148, 1518500249
%251 = add i32 %250, %221
%252 = add i32 %251, %249
%253 = tail call i32 @llvm.fshl.i32(i32 %252, i32 %252, i32 9)
%254 = or i32 %245, %237
%255 = and i32 %253, %254
%256 = and i32 %245, %237
%257 = or i32 %255, %256
%258 = add i32 %180, 1518500249
%259 = add i32 %258, %229
%260 = add i32 %259, %257
%261 = tail call i32 @llvm.fshl.i32(i32 %260, i32 %260, i32 13)
%262 = or i32 %253, %245
%263 = and i32 %261, %262
%264 = and i32 %253, %245
%265 = or i32 %263, %264
%266 = add i32 %92, 1518500249
%267 = add i32 %266, %237
%268 = add i32 %267, %265
%269 = tail call i32 @llvm.fshl.i32(i32 %268, i32 %268, i32 3)
%270 = or i32 %261, %253
%271 = and i32 %269, %270
%272 = and i32 %261, %253
%273 = or i32 %271, %272
%274 = add i32 %124, 1518500249
%275 = add i32 %274, %245
%276 = add i32 %275, %273
%277 = tail call i32 @llvm.fshl.i32(i32 %276, i32 %276, i32 5)
%278 = or i32 %269, %261
%279 = and i32 %277, %278
%280 = and i32 %269, %261
%281 = or i32 %279, %280
%282 = add i32 %156, 1518500249
%283 = add i32 %282, %253
%284 = add i32 %283, %281
%285 = tail call i32 @llvm.fshl.i32(i32 %284, i32 %284, i32 9)
%286 = or i32 %277, %269
%287 = and i32 %285, %286
%288 = and i32 %277, %269
%289 = or i32 %287, %288
%290 = add i32 %77, 1518500249
%291 = add i32 %290, %261
%292 = add i32 %291, %289
%293 = tail call i32 @llvm.fshl.i32(i32 %292, i32 %292, i32 13)
%294 = or i32 %285, %277
%295 = and i32 %293, %294
%296 = and i32 %285, %277
%297 = or i32 %295, %296
%298 = add i32 %100, 1518500249
%299 = add i32 %298, %269
%300 = add i32 %299, %297
%301 = tail call i32 @llvm.fshl.i32(i32 %300, i32 %300, i32 3)
%302 = or i32 %293, %285
%303 = and i32 %301, %302
%304 = and i32 %293, %285
%305 = or i32 %303, %304
%306 = add i32 %132, 1518500249
%307 = add i32 %306, %277
%308 = add i32 %307, %305
%309 = tail call i32 @llvm.fshl.i32(i32 %308, i32 %308, i32 5)
%310 = or i32 %301, %293
%311 = and i32 %309, %310
%312 = and i32 %301, %293
%313 = or i32 %311, %312
%314 = add i32 %164, 1518500249
%315 = add i32 %314, %285
%316 = add i32 %315, %313
%317 = tail call i32 @llvm.fshl.i32(i32 %316, i32 %316, i32 9)
%318 = or i32 %309, %301
%319 = and i32 %317, %318
%320 = and i32 %309, %301
%321 = or i32 %319, %320
%322 = add i32 %194, 1518500249
%323 = add i32 %322, %293
%324 = add i32 %323, %321
%325 = tail call i32 @llvm.fshl.i32(i32 %324, i32 %324, i32 13)
%326 = xor i32 %325, %317
%327 = xor i32 %326, %309
%328 = add i32 %78, 1859775393
%329 = add i32 %328, %301
%330 = add i32 %329, %327
%331 = tail call i32 @llvm.fshl.i32(i32 %330, i32 %330, i32 3)
%332 = xor i32 %331, %325
%333 = xor i32 %332, %317
%334 = add i32 %140, 1859775393
%335 = add i32 %334, %309
%336 = add i32 %335, %333
%337 = tail call i32 @llvm.fshl.i32(i32 %336, i32 %336, i32 9)
%338 = xor i32 %332, %337
%339 = add i32 %108, 1859775393
%340 = add i32 %339, %317
%341 = add i32 %340, %338
%342 = tail call i32 @llvm.fshl.i32(i32 %341, i32 %341, i32 11)
%343 = xor i32 %337, %331
%344 = xor i32 %343, %342
%345 = add i32 %172, 1859775393
%346 = add i32 %345, %325
%347 = add i32 %346, %344
%348 = tail call i32 @llvm.fshl.i32(i32 %347, i32 %347, i32 15)
%349 = xor i32 %342, %337
%350 = xor i32 %349, %348
%351 = add i32 %92, 1859775393
%352 = add i32 %351, %331
%353 = add i32 %352, %350
%354 = tail call i32 @llvm.fshl.i32(i32 %353, i32 %353, i32 3)
%355 = xor i32 %348, %342
%356 = xor i32 %355, %354
%357 = add i32 %156, 1859775393
%358 = add i32 %357, %337
%359 = add i32 %358, %356
%360 = tail call i32 @llvm.fshl.i32(i32 %359, i32 %359, i32 9)
%361 = xor i32 %354, %348
%362 = xor i32 %361, %360
%363 = add i32 %124, 1859775393
%364 = add i32 %363, %342
%365 = add i32 %364, %362
%366 = tail call i32 @llvm.fshl.i32(i32 %365, i32 %365, i32 11)
%367 = xor i32 %360, %354
%368 = xor i32 %367, %366
%369 = add i32 %77, 1859775393
%370 = add i32 %369, %348
%371 = add i32 %370, %368
%372 = tail call i32 @llvm.fshl.i32(i32 %371, i32 %371, i32 15)
%373 = xor i32 %366, %360
%374 = xor i32 %373, %372
%375 = add i32 %84, 1859775393
%376 = add i32 %375, %354
%377 = add i32 %376, %374
%378 = tail call i32 @llvm.fshl.i32(i32 %377, i32 %377, i32 3)
%379 = xor i32 %372, %366
%380 = xor i32 %379, %378
%381 = add i32 %148, 1859775393
%382 = add i32 %381, %360
%383 = add i32 %382, %380
%384 = tail call i32 @llvm.fshl.i32(i32 %383, i32 %383, i32 9)
%385 = xor i32 %378, %372
%386 = xor i32 %385, %384
%387 = add i32 %116, 1859775393
%388 = add i32 %387, %366
%389 = add i32 %388, %386
%390 = tail call i32 @llvm.fshl.i32(i32 %389, i32 %389, i32 11)
%391 = xor i32 %384, %378
%392 = xor i32 %391, %390
%393 = add i32 %180, 1859775393
%394 = add i32 %393, %372
%395 = add i32 %394, %392
%396 = tail call i32 @llvm.fshl.i32(i32 %395, i32 %395, i32 15)
%397 = xor i32 %390, %384
%398 = xor i32 %397, %396
%399 = add i32 %100, 1859775393
%400 = add i32 %399, %378
%401 = add i32 %400, %398
%402 = tail call i32 @llvm.fshl.i32(i32 %401, i32 %401, i32 3)
%403 = xor i32 %396, %390
%404 = xor i32 %403, %402
%405 = add i32 %164, 1859775393
%406 = add i32 %405, %384
%407 = add i32 %406, %404
%408 = tail call i32 @llvm.fshl.i32(i32 %407, i32 %407, i32 9)
%409 = xor i32 %402, %396
%410 = xor i32 %409, %408
%411 = add i32 %132, 1859775393
%412 = add i32 %411, %390
%413 = add i32 %412, %410
%414 = tail call i32 @llvm.fshl.i32(i32 %413, i32 %413, i32 11)
%415 = xor i32 %408, %402
%416 = xor i32 %415, %414
%417 = add i32 %194, 1859775393
%418 = add i32 %417, %396
%419 = add i32 %418, %416
%420 = tail call i32 @llvm.fshl.i32(i32 %419, i32 %419, i32 15)
%421 = add i32 %402, 1732584193
%422 = add i32 %420, -271733879
%423 = add i32 %414, -1732584194
%424 = add i32 %408, 271733878
%425 = and i32 %421, 15
%426 = zext i32 %425 to i64
%427 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %426
%428 = load i8, i8* %427
store i8 %428, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 1)
%429 = lshr i32 %421, 4
%430 = and i32 %429, 15
%431 = zext i32 %430 to i64
%432 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %431
%433 = load i8, i8* %432
store i8 %433, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 0)
%434 = lshr i32 %421, 8
%435 = and i32 %434, 15
%436 = zext i32 %435 to i64
%437 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %436
%438 = load i8, i8* %437
store i8 %438, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 3)
%439 = lshr i32 %421, 12
%440 = and i32 %439, 15
%441 = zext i32 %440 to i64
%442 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %441
%443 = load i8, i8* %442
store i8 %443, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 2)
%444 = lshr i32 %421, 16
%445 = and i32 %444, 15
%446 = zext i32 %445 to i64
%447 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %446
%448 = load i8, i8* %447
store i8 %448, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 5)
%449 = lshr i32 %421, 20
%450 = and i32 %449, 15
%451 = zext i32 %450 to i64
%452 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %451
%453 = load i8, i8* %452
store i8 %453, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 4)
%454 = lshr i32 %421, 24
%455 = and i32 %454, 15
%456 = zext i32 %455 to i64
%457 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %456
%458 = load i8, i8* %457
store i8 %458, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 7)
%459 = lshr i32 %421, 28
%460 = zext i32 %459 to i64
%461 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %460
%462 = load i8, i8* %461
store i8 %462, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 6)
%463 = and i32 %422, 15
%464 = zext i32 %463 to i64
%465 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %464
%466 = load i8, i8* %465
store i8 %466, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 9)
%467 = lshr i32 %422, 4
%468 = and i32 %467, 15
%469 = zext i32 %468 to i64
%470 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %469
%471 = load i8, i8* %470
store i8 %471, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 8)
%472 = lshr i32 %422, 8
%473 = and i32 %472, 15
%474 = zext i32 %473 to i64
%475 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %474
%476 = load i8, i8* %475
store i8 %476, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 11)
%477 = lshr i32 %422, 12
%478 = and i32 %477, 15
%479 = zext i32 %478 to i64
%480 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %479
%481 = load i8, i8* %480
store i8 %481, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 10)
%482 = lshr i32 %422, 16
%483 = and i32 %482, 15
%484 = zext i32 %483 to i64
%485 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %484
%486 = load i8, i8* %485
store i8 %486, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 13)
%487 = lshr i32 %422, 20
%488 = and i32 %487, 15
%489 = zext i32 %488 to i64
%490 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %489
%491 = load i8, i8* %490
store i8 %491, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 12)
%492 = lshr i32 %422, 24
%493 = and i32 %492, 15
%494 = zext i32 %493 to i64
%495 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %494
%496 = load i8, i8* %495
store i8 %496, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 15)
%497 = lshr i32 %422, 28
%498 = zext i32 %497 to i64
%499 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %498
%500 = load i8, i8* %499
store i8 %500, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 14)
%501 = and i32 %423, 15
%502 = zext i32 %501 to i64
%503 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %502
%504 = load i8, i8* %503
store i8 %504, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 17)
%505 = lshr i32 %423, 4
%506 = and i32 %505, 15
%507 = zext i32 %506 to i64
%508 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %507
%509 = load i8, i8* %508
store i8 %509, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 16)
%510 = lshr i32 %423, 8
%511 = and i32 %510, 15
%512 = zext i32 %511 to i64
%513 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %512
%514 = load i8, i8* %513
store i8 %514, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 19)
%515 = lshr i32 %423, 12
%516 = and i32 %515, 15
%517 = zext i32 %516 to i64
%518 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %517
%519 = load i8, i8* %518
store i8 %519, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 18)
%520 = lshr i32 %423, 16
%521 = and i32 %520, 15
%522 = zext i32 %521 to i64
%523 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %522
%524 = load i8, i8* %523
store i8 %524, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 21)
%525 = lshr i32 %423, 20
%526 = and i32 %525, 15
%527 = zext i32 %526 to i64
%528 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %527
%529 = load i8, i8* %528
store i8 %529, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 20)
%530 = lshr i32 %423, 24
%531 = and i32 %530, 15
%532 = zext i32 %531 to i64
%533 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %532
%534 = load i8, i8* %533
store i8 %534, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 23)
%535 = lshr i32 %423, 28
%536 = zext i32 %535 to i64
%537 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %536
%538 = load i8, i8* %537
store i8 %538, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 22)
%539 = and i32 %424, 15
%540 = zext i32 %539 to i64
%541 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %540
%542 = load i8, i8* %541
store i8 %542, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 25)
%543 = lshr i32 %424, 4
%544 = and i32 %543, 15
%545 = zext i32 %544 to i64
%546 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %545
%547 = load i8, i8* %546
store i8 %547, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 24)
%548 = lshr i32 %424, 8
%549 = and i32 %548, 15
%550 = zext i32 %549 to i64
%551 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %550
%552 = load i8, i8* %551
store i8 %552, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 27)
%553 = lshr i32 %424, 12
%554 = and i32 %553, 15
%555 = zext i32 %554 to i64
%556 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %555
%557 = load i8, i8* %556
store i8 %557, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 26)
%558 = lshr i32 %424, 16
%559 = and i32 %558, 15
%560 = zext i32 %559 to i64
%561 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %560
%562 = load i8, i8* %561
store i8 %562, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 29)
%563 = lshr i32 %424, 20
%564 = and i32 %563, 15
%565 = zext i32 %564 to i64
%566 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %565
%567 = load i8, i8* %566
store i8 %567, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 28)
%568 = lshr i32 %424, 24
%569 = and i32 %568, 15
%570 = zext i32 %569 to i64
%571 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %570
%572 = load i8, i8* %571
store i8 %572, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 31)
%573 = lshr i32 %424, 28
%574 = zext i32 %573 to i64
%575 = getelementptr inbounds [16 x i8], [16 x i8]* @__const.ntlm_crypt.itoa16, i64 0, i64 %574
%576 = load i8, i8* %575
store i8 %576, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 30)
store i8 0, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 1, i64 0)
ret i8* getelementptr inbounds ([33 x i8], [33 x i8]* @ntlm_crypt.hex_format, i64 0, i64 0)
}