#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint;
typedef int /*<<< orphan*/ k_opad;
typedef int /*<<< orphan*/ k_ipad;
typedef int /*<<< orphan*/ buffer;

/* Variables and functions */
int /*<<< orphan*/ EVP_sha1();
int /*<<< orphan*/ HMAC(int /*<<< orphan*/, unsigned char *, int,
                        unsigned char *, int, unsigned char *,
                        int /*<<< orphan*/ *);
int /*<<< orphan*/ memcpy(unsigned char *, ...);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ shasse2_data(unsigned char *, unsigned char *,
                                unsigned char *);
int /*<<< orphan*/ shasse2_ends(unsigned char *, unsigned char *);
int /*<<< orphan*/ shasse2_init(unsigned char *);
int strlen(char *);
int /*<<< orphan*/ strncpy(char *, char *, int);
void calc_4pmk(char *_key1, char *_key2, char *_key3, char *_key4, char *_essid,
               unsigned char *_pmk1, unsigned char *_pmk2, unsigned char *_pmk3,
               unsigned char *_pmk4) {
  int slen;
  char essid[36] __attribute__((aligned(16)));
  char key1[128] __attribute__((aligned(16)));
  char key2[128] __attribute__((aligned(16)));
  char key3[128] __attribute__((aligned(16)));
  char key4[128] __attribute__((aligned(16)));
  unsigned char pmks[128 * 4] __attribute__((aligned(16)));
  unsigned char k_ipad[256] __attribute__((aligned(16)));
  unsigned char ctx_ipad[80] __attribute__((aligned(16)));
  unsigned char k_opad[256] __attribute__((aligned(16)));
  unsigned char ctx_opad[80] __attribute__((aligned(16)));
  unsigned char buffer[256] __attribute__((aligned(16)));
  unsigned char sha1_ctx[80] __attribute__((aligned(16)));
  unsigned char wrkbuf[1280] __attribute__((aligned(16)));
  uint i, *u, *v, *w, *u3, *v4;
  unsigned char *pmk1, *pmk2, *pmk3, *pmk4;
  pmk1 = pmks;
  pmk2 = pmks + 128;
  pmk3 = pmks + 128 * 2;
  pmk4 = pmks + 128 * 3;
  strncpy(essid, _essid, 35);
  strncpy(key1, _key1, 127);
  strncpy(key2, _key2, 127);
  strncpy(key3, _key3, 127);
  strncpy(key4, _key4, 127);
  slen = strlen(essid) + 4;
  memset(k_ipad, 0, sizeof(k_ipad));
  memset(k_opad, 0, sizeof(k_opad));
  memcpy(k_ipad, key1, strlen(key1));
  memcpy(k_opad, key1, strlen(key1));
  memcpy(k_ipad + 64, key2, strlen(key2));
  memcpy(k_opad + 64, key2, strlen(key2));
  memcpy(k_ipad + 128, key3, strlen(key3));
  memcpy(k_opad + 128, key3, strlen(key3));
  memcpy(k_ipad + 192, key4, strlen(key4));
  memcpy(k_opad + 192, key4, strlen(key4));
  u = (uint *)(k_ipad);
  v = (uint *)(k_ipad + 64);
  u3 = (uint *)(k_ipad + 128);
  v4 = (uint *)(k_ipad + 192);
  w = (uint *)buffer;
  for (i = 0; i < 16; i++) {
    *w++ = *u++ ^ 0x36363636;
    *w++ = *v++ ^ 0x36363636;
    *w++ = *u3++ ^ 0x36363636;
    *w++ = *v4++ ^ 0x36363636;
  }
  shasse2_init(ctx_ipad);
  shasse2_data(ctx_ipad, buffer, wrkbuf);
  u = (uint *)(k_opad);
  v = (uint *)(k_opad + 64);
  u3 = (uint *)(k_opad + 128);
  v4 = (uint *)(k_opad + 192);
  w = (uint *)buffer;
  for (i = 0; i < 16; i++) {
    *w++ = *u++ ^ 0x5C5C5C5C;
    *w++ = *v++ ^ 0x5C5C5C5C;
    *w++ = *u3++ ^ 0x5C5C5C5C;
    *w++ = *v4++ ^ 0x5C5C5C5C;
  }
  shasse2_init(ctx_opad);
  shasse2_data(ctx_opad, buffer, wrkbuf);
  memset(buffer, 0, sizeof(buffer));
  buffer[80] = buffer[84] = buffer[88] = buffer[92] = 0x80;
  buffer[242] = buffer[246] = buffer[250] = buffer[254] = 0x02;
  buffer[243] = buffer[247] = buffer[251] = buffer[255] = 0xA0;
  essid[slen - 1] = '\1';
  HMAC(EVP_sha1(), (unsigned char *)key1, strlen(key1), (unsigned char *)essid,
       slen, pmk1, NULL);
  HMAC(EVP_sha1(), (unsigned char *)key2, strlen(key2), (unsigned char *)essid,
       slen, pmk2, NULL);
  HMAC(EVP_sha1(), (unsigned char *)key3, strlen(key3), (unsigned char *)essid,
       slen, pmk3, NULL);
  HMAC(EVP_sha1(), (unsigned char *)key4, strlen(key4), (unsigned char *)essid,
       slen, pmk4, NULL);
  u = (uint *)pmk1;
  v = (uint *)pmk2;
  u3 = (uint *)pmk3;
  v4 = (uint *)pmk4;
  w = (uint *)buffer;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  for (i = 1; i < 4096; i++) {
    memcpy(sha1_ctx, ctx_ipad, 80);
    shasse2_data(sha1_ctx, buffer, wrkbuf);
    shasse2_ends(sha1_ctx, buffer);
    memcpy(sha1_ctx, ctx_opad, 80);
    shasse2_data(sha1_ctx, buffer, wrkbuf);
    shasse2_ends(sha1_ctx, buffer);
    u = (uint *)pmk1;
    v = (uint *)pmk2;
    u3 = (uint *)pmk3;
    v4 = (uint *)pmk4;
    w = (uint *)buffer;
    *u++ ^= *w++;
    *v++ ^= *w++;
    *u3++ ^= *w++;
    *v4++ ^= *w++;
    *u++ ^= *w++;
    *v++ ^= *w++;
    *u3++ ^= *w++;
    *v4++ ^= *w++;
    *u++ ^= *w++;
    *v++ ^= *w++;
    *u3++ ^= *w++;
    *v4++ ^= *w++;
    *u++ ^= *w++;
    *v++ ^= *w++;
    *u3++ ^= *w++;
    *v4++ ^= *w++;
    *u++ ^= *w++;
    *v++ ^= *w++;
    *u3++ ^= *w++;
    *v4++ ^= *w++;
  }
  essid[slen - 1] = '\2';
  HMAC(EVP_sha1(), (unsigned char *)key1, strlen(key1), (unsigned char *)essid,
       slen, pmk1 + 20, NULL);
  HMAC(EVP_sha1(), (unsigned char *)key2, strlen(key2), (unsigned char *)essid,
       slen, pmk2 + 20, NULL);
  HMAC(EVP_sha1(), (unsigned char *)key3, strlen(key3), (unsigned char *)essid,
       slen, pmk3 + 20, NULL);
  HMAC(EVP_sha1(), (unsigned char *)key4, strlen(key4), (unsigned char *)essid,
       slen, pmk4 + 20, NULL);
  u = (uint *)(pmk1 + 20);
  v = (uint *)(pmk2 + 20);
  u3 = (uint *)(pmk3 + 20);
  v4 = (uint *)(pmk4 + 20);
  w = (uint *)buffer;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  *w++ = *u++;
  *w++ = *v++;
  *w++ = *u3++;
  *w++ = *v4++;
  for (i = 1; i < 4096; i++) {
    memcpy(sha1_ctx, ctx_ipad, 80);
    shasse2_data(sha1_ctx, buffer, wrkbuf);
    shasse2_ends(sha1_ctx, buffer);
    memcpy(sha1_ctx, ctx_opad, 80);
    shasse2_data(sha1_ctx, buffer, wrkbuf);
    shasse2_ends(sha1_ctx, buffer);
    u = (uint *)(pmk1 + 20);
    v = (uint *)(pmk2 + 20);
    u3 = (uint *)(pmk3 + 20);
    v4 = (uint *)(pmk4 + 20);
    w = (uint *)buffer;
    *u++ ^= *w++;
    *v++ ^= *w++;
    *u3++ ^= *w++;
    *v4++ ^= *w++;
    *u++ ^= *w++;
    *v++ ^= *w++;
    *u3++ ^= *w++;
    *v4++ ^= *w++;
    *u++ ^= *w++;
    *v++ ^= *w++;
    *u3++ ^= *w++;
    *v4++ ^= *w++;
  }
  memcpy(_pmk3, pmk3, 32);
  memcpy(_pmk4, pmk4, 32);
  memcpy(_pmk1, pmk1, 32);
  memcpy(_pmk2, pmk2, 32);
}


x86 assembly (clang, -O0):
<calc_4pmk>:
push   %rbp
mov    %rsp,%rbp
sub    $0xeb0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
lea    -0x460(%rbp),%rax
mov    %rax,-0xd88(%rbp)
lea    -0x460(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0xd90(%rbp)
lea    -0x460(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0xd98(%rbp)
lea    -0x460(%rbp),%rax
add    $0x180,%rax
mov    %rax,-0xda0(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    $0x23,%edx
call   1030 <strncpy@plt>
lea    -0xe0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0x7f,%edx
call   1030 <strncpy@plt>
lea    -0x160(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    $0x7f,%edx
call   1030 <strncpy@plt>
lea    -0x1e0(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x7f,%edx
call   1030 <strncpy@plt>
lea    -0x260(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    $0x7f,%edx
call   1030 <strncpy@plt>
lea    -0x60(%rbp),%rdi
call   1040 <strlen@plt>
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
lea    -0x560(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1070 <memset@plt>
lea    -0x6b0(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1070 <memset@plt>
lea    -0x560(%rbp),%rax
mov    %rax,-0xe20(%rbp)
lea    -0xe0(%rbp),%rax
mov    %rax,-0xe18(%rbp)
lea    -0xe0(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe20(%rbp),%rdi
mov    -0xe18(%rbp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    -0x6b0(%rbp),%rax
mov    %rax,-0xe10(%rbp)
lea    -0xe0(%rbp),%rax
mov    %rax,-0xe08(%rbp)
lea    -0xe0(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe10(%rbp),%rdi
mov    -0xe08(%rbp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    -0x560(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xe00(%rbp)
lea    -0x160(%rbp),%rax
mov    %rax,-0xdf8(%rbp)
lea    -0x160(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe00(%rbp),%rdi
mov    -0xdf8(%rbp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    -0x6b0(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xdf0(%rbp)
lea    -0x160(%rbp),%rax
mov    %rax,-0xde8(%rbp)
lea    -0x160(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xdf0(%rbp),%rdi
mov    -0xde8(%rbp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    -0x560(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0xde0(%rbp)
lea    -0x1e0(%rbp),%rax
mov    %rax,-0xdd8(%rbp)
lea    -0x1e0(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xde0(%rbp),%rdi
mov    -0xdd8(%rbp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    -0x6b0(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0xdd0(%rbp)
lea    -0x1e0(%rbp),%rax
mov    %rax,-0xdc8(%rbp)
lea    -0x1e0(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xdd0(%rbp),%rdi
mov    -0xdc8(%rbp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    -0x560(%rbp),%rax
add    $0xc0,%rax
mov    %rax,-0xdc0(%rbp)
lea    -0x260(%rbp),%rax
mov    %rax,-0xdb8(%rbp)
lea    -0x260(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xdc0(%rbp),%rdi
mov    -0xdb8(%rbp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    -0x6b0(%rbp),%rax
add    $0xc0,%rax
mov    %rax,-0xdb0(%rbp)
lea    -0x260(%rbp),%rax
mov    %rax,-0xda8(%rbp)
lea    -0x260(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xdb0(%rbp),%rdi
mov    -0xda8(%rbp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    -0x560(%rbp),%rax
mov    %rax,-0xd60(%rbp)
lea    -0x560(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xd68(%rbp)
lea    -0x560(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0xd78(%rbp)
lea    -0x560(%rbp),%rax
add    $0xc0,%rax
mov    %rax,-0xd80(%rbp)
lea    -0x800(%rbp),%rax
mov    %rax,-0xd70(%rbp)
movl   $0x0,-0xd54(%rbp)
cmpl   $0x10,-0xd54(%rbp)
jge    160d <calc_4pmk+0x47d>
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
xor    $0x36363636,%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
xor    $0x36363636,%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
xor    $0x36363636,%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
xor    $0x36363636,%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd54(%rbp)
jmp    151c <calc_4pmk+0x38c>
lea    -0x5b0(%rbp),%rdi
call   1080 <shasse2_init@plt>
lea    -0x5b0(%rbp),%rdi
lea    -0x800(%rbp),%rsi
lea    -0xd50(%rbp),%rdx
call   1060 <shasse2_data@plt>
lea    -0x6b0(%rbp),%rax
mov    %rax,-0xd60(%rbp)
lea    -0x6b0(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xd68(%rbp)
lea    -0x6b0(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0xd78(%rbp)
lea    -0x6b0(%rbp),%rax
add    $0xc0,%rax
mov    %rax,-0xd80(%rbp)
lea    -0x800(%rbp),%rax
mov    %rax,-0xd70(%rbp)
movl   $0x0,-0xd54(%rbp)
cmpl   $0x10,-0xd54(%rbp)
jge    1784 <calc_4pmk+0x5f4>
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
xor    $0x5c5c5c5c,%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
xor    $0x5c5c5c5c,%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
xor    $0x5c5c5c5c,%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
xor    $0x5c5c5c5c,%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd54(%rbp)
jmp    1693 <calc_4pmk+0x503>
lea    -0x700(%rbp),%rdi
call   1080 <shasse2_init@plt>
lea    -0x700(%rbp),%rdi
lea    -0x800(%rbp),%rsi
lea    -0xd50(%rbp),%rdx
call   1060 <shasse2_data@plt>
lea    -0x800(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1070 <memset@plt>
movb   $0x80,-0x7a4(%rbp)
movb   $0x80,-0x7a8(%rbp)
movb   $0x80,-0x7ac(%rbp)
movb   $0x80,-0x7b0(%rbp)
movb   $0x2,-0x702(%rbp)
movb   $0x2,-0x706(%rbp)
movb   $0x2,-0x70a(%rbp)
movb   $0x2,-0x70e(%rbp)
movb   $0xa0,-0x701(%rbp)
movb   $0xa0,-0x705(%rbp)
movb   $0xa0,-0x709(%rbp)
movb   $0xa0,-0x70d(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x1,-0x60(%rbp,%rax,1)
mov    $0x0,%al
call   1050 <EVP_sha1@plt>
mov    %eax,-0xe5c(%rbp)
lea    -0xe0(%rbp),%rax
mov    %rax,-0xe58(%rbp)
lea    -0xe0(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe5c(%rbp),%edi
mov    -0xe58(%rbp),%rsi
mov    %eax,%edx
lea    -0x60(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    -0xd88(%rbp),%r9
xor    %eax,%eax
movq   $0x0,(%rsp)
call   10a0 <HMAC@plt>
mov    $0x0,%al
call   1050 <EVP_sha1@plt>
mov    %eax,-0xe4c(%rbp)
lea    -0x160(%rbp),%rax
mov    %rax,-0xe48(%rbp)
lea    -0x160(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe4c(%rbp),%edi
mov    -0xe48(%rbp),%rsi
mov    %eax,%edx
lea    -0x60(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    -0xd90(%rbp),%r9
xor    %eax,%eax
movq   $0x0,(%rsp)
call   10a0 <HMAC@plt>
mov    $0x0,%al
call   1050 <EVP_sha1@plt>
mov    %eax,-0xe3c(%rbp)
lea    -0x1e0(%rbp),%rax
mov    %rax,-0xe38(%rbp)
lea    -0x1e0(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe3c(%rbp),%edi
mov    -0xe38(%rbp),%rsi
mov    %eax,%edx
lea    -0x60(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    -0xd98(%rbp),%r9
xor    %eax,%eax
movq   $0x0,(%rsp)
call   10a0 <HMAC@plt>
mov    $0x0,%al
call   1050 <EVP_sha1@plt>
mov    %eax,-0xe2c(%rbp)
lea    -0x260(%rbp),%rax
mov    %rax,-0xe28(%rbp)
lea    -0x260(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe2c(%rbp),%edi
mov    -0xe28(%rbp),%rsi
mov    %eax,%edx
lea    -0x60(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    -0xda0(%rbp),%r9
xor    %eax,%eax
movq   $0x0,(%rsp)
call   10a0 <HMAC@plt>
mov    -0xd88(%rbp),%rax
mov    %rax,-0xd60(%rbp)
mov    -0xd90(%rbp),%rax
mov    %rax,-0xd68(%rbp)
mov    -0xd98(%rbp),%rax
mov    %rax,-0xd78(%rbp)
mov    -0xda0(%rbp),%rax
mov    %rax,-0xd80(%rbp)
lea    -0x800(%rbp),%rax
mov    %rax,-0xd70(%rbp)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
movl   $0x1,-0xd54(%rbp)
cmpl   $0x1000,-0xd54(%rbp)
jge    220e <calc_4pmk+0x107e>
lea    -0x850(%rbp),%rdi
lea    -0x5b0(%rbp),%rsi
xor    %eax,%eax
mov    $0x50,%edx
call   1090 <memcpy@plt>
lea    -0x850(%rbp),%rdi
lea    -0x800(%rbp),%rsi
lea    -0xd50(%rbp),%rdx
call   1060 <shasse2_data@plt>
lea    -0x850(%rbp),%rdi
lea    -0x800(%rbp),%rsi
call   10b0 <shasse2_ends@plt>
lea    -0x850(%rbp),%rdi
lea    -0x700(%rbp),%rsi
xor    %eax,%eax
mov    $0x50,%edx
call   1090 <memcpy@plt>
lea    -0x850(%rbp),%rdi
lea    -0x800(%rbp),%rsi
lea    -0xd50(%rbp),%rdx
call   1060 <shasse2_data@plt>
lea    -0x850(%rbp),%rdi
lea    -0x800(%rbp),%rsi
call   10b0 <shasse2_ends@plt>
mov    -0xd88(%rbp),%rax
mov    %rax,-0xd60(%rbp)
mov    -0xd90(%rbp),%rax
mov    %rax,-0xd68(%rbp)
mov    -0xd98(%rbp),%rax
mov    %rax,-0xd78(%rbp)
mov    -0xda0(%rbp),%rax
mov    %rax,-0xd80(%rbp)
lea    -0x800(%rbp),%rax
mov    %rax,-0xd70(%rbp)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd60(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd68(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd78(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd80(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd60(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd68(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd78(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd80(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd60(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd68(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd78(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd80(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd60(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd68(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd78(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd80(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd60(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd68(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd78(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd80(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd54(%rbp)
jmp    1d56 <calc_4pmk+0xbc6>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x2,-0x60(%rbp,%rax,1)
mov    $0x0,%al
call   1050 <EVP_sha1@plt>
mov    %eax,-0xe9c(%rbp)
lea    -0xe0(%rbp),%rax
mov    %rax,-0xe98(%rbp)
lea    -0xe0(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe9c(%rbp),%edi
mov    -0xe98(%rbp),%rsi
mov    %eax,%edx
lea    -0x60(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    -0xd88(%rbp),%r9
add    $0x14,%r9
xor    %eax,%eax
movq   $0x0,(%rsp)
call   10a0 <HMAC@plt>
mov    $0x0,%al
call   1050 <EVP_sha1@plt>
mov    %eax,-0xe8c(%rbp)
lea    -0x160(%rbp),%rax
mov    %rax,-0xe88(%rbp)
lea    -0x160(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe8c(%rbp),%edi
mov    -0xe88(%rbp),%rsi
mov    %eax,%edx
lea    -0x60(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    -0xd90(%rbp),%r9
add    $0x14,%r9
xor    %eax,%eax
movq   $0x0,(%rsp)
call   10a0 <HMAC@plt>
mov    $0x0,%al
call   1050 <EVP_sha1@plt>
mov    %eax,-0xe7c(%rbp)
lea    -0x1e0(%rbp),%rax
mov    %rax,-0xe78(%rbp)
lea    -0x1e0(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe7c(%rbp),%edi
mov    -0xe78(%rbp),%rsi
mov    %eax,%edx
lea    -0x60(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    -0xd98(%rbp),%r9
add    $0x14,%r9
xor    %eax,%eax
movq   $0x0,(%rsp)
call   10a0 <HMAC@plt>
mov    $0x0,%al
call   1050 <EVP_sha1@plt>
mov    %eax,-0xe6c(%rbp)
lea    -0x260(%rbp),%rax
mov    %rax,-0xe68(%rbp)
lea    -0x260(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xe6c(%rbp),%edi
mov    -0xe68(%rbp),%rsi
mov    %eax,%edx
lea    -0x60(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    -0xda0(%rbp),%r9
add    $0x14,%r9
xor    %eax,%eax
movq   $0x0,(%rsp)
call   10a0 <HMAC@plt>
mov    -0xd88(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0xd60(%rbp)
mov    -0xd90(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0xd68(%rbp)
mov    -0xd98(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0xd78(%rbp)
mov    -0xda0(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0xd80(%rbp)
lea    -0x800(%rbp),%rax
mov    %rax,-0xd70(%rbp)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd60(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd68(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd78(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
mov    -0xd80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd80(%rbp)
mov    (%rax),%ecx
mov    -0xd70(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd70(%rbp)
mov    %ecx,(%rax)
movl   $0x1,-0xd54(%rbp)
cmpl   $0x1000,-0xd54(%rbp)
jge    2abb <calc_4pmk+0x192b>
lea    -0x850(%rbp),%rdi
lea    -0x5b0(%rbp),%rsi
xor    %eax,%eax
mov    $0x50,%edx
call   1090 <memcpy@plt>
lea    -0x850(%rbp),%rdi
lea    -0x800(%rbp),%rsi
lea    -0xd50(%rbp),%rdx
call   1060 <shasse2_data@plt>
lea    -0x850(%rbp),%rdi
lea    -0x800(%rbp),%rsi
call   10b0 <shasse2_ends@plt>
lea    -0x850(%rbp),%rdi
lea    -0x700(%rbp),%rsi
xor    %eax,%eax
mov    $0x50,%edx
call   1090 <memcpy@plt>
lea    -0x850(%rbp),%rdi
lea    -0x800(%rbp),%rsi
lea    -0xd50(%rbp),%rdx
call   1060 <shasse2_data@plt>
lea    -0x850(%rbp),%rdi
lea    -0x800(%rbp),%rsi
call   10b0 <shasse2_ends@plt>
mov    -0xd88(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0xd60(%rbp)
mov    -0xd90(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0xd68(%rbp)
mov    -0xd98(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0xd78(%rbp)
mov    -0xda0(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0xd80(%rbp)
lea    -0x800(%rbp),%rax
mov    %rax,-0xd70(%rbp)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd60(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd68(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd78(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd80(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd60(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd68(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd78(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd80(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd60(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd68(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd78(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd70(%rbp)
mov    (%rax),%ecx
mov    -0xd80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0xd80(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xd54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd54(%rbp)
jmp    2773 <calc_4pmk+0x15e3>
mov    0x18(%rbp),%rdi
mov    -0xd98(%rbp),%rsi
xor    %eax,%eax
mov    $0x20,%edx
call   1090 <memcpy@plt>
mov    0x20(%rbp),%rdi
mov    -0xda0(%rbp),%rsi
xor    %eax,%eax
mov    $0x20,%edx
call   1090 <memcpy@plt>
mov    -0x30(%rbp),%rdi
mov    -0xd88(%rbp),%rsi
xor    %eax,%eax
mov    $0x20,%edx
call   1090 <memcpy@plt>
mov    0x10(%rbp),%rdi
mov    -0xd90(%rbp),%rsi
xor    %eax,%eax
mov    $0x20,%edx
call   1090 <memcpy@plt>
add    $0xeb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc_4pmk>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd48,%rsp
mov    %r9,0x118(%rsp)
mov    %rcx,%r14
mov    %rdx,%r12
mov    %rsi,%rbp
mov    %rdi,%rbx
lea    0x120(%rsp),%r13
mov    %r13,%rdi
mov    %r8,%rsi
mov    $0x23,%edx
call   1030 <strncpy@plt>
lea    0x7c0(%rsp),%r15
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x7f,%edx
call   1030 <strncpy@plt>
lea    0x6a0(%rsp),%rdi
mov    %rbp,%rsi
mov    $0x7f,%edx
call   1030 <strncpy@plt>
lea    0x620(%rsp),%rdi
mov    %r12,%rsi
mov    $0x7f,%edx
call   1030 <strncpy@plt>
lea    0x5a0(%rsp),%rdi
mov    %r14,%rsi
mov    $0x7f,%edx
call   1030 <strncpy@plt>
mov    %r13,%rdi
call   1040 <strlen@plt>
mov    %eax,%r13d
lea    0x450(%rsp),%rbx
xor    %r12d,%r12d
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1070 <memset@plt>
lea    0x350(%rsp),%r14
mov    %r14,%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1070 <memset@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %r14,%rdi
mov    %r15,%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    0x490(%rsp),%rbx
lea    0x6a0(%rsp),%rbp
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    0x390(%rsp),%rbx
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    0x4d0(%rsp),%rbx
lea    0x620(%rsp),%rbp
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    0x3d0(%rsp),%rbx
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    0x510(%rsp),%rbx
lea    0x5a0(%rsp),%rbp
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    0x410(%rsp),%rbx
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
mov    $0x36363636,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x450(%rsp,%r12,1),%ecx
xor    %eax,%ecx
mov    %ecx,0x10(%rsp,%r12,4)
mov    0x490(%rsp,%r12,1),%ecx
xor    %eax,%ecx
mov    %ecx,0x14(%rsp,%r12,4)
mov    0x4d0(%rsp,%r12,1),%ecx
xor    %eax,%ecx
mov    %ecx,0x18(%rsp,%r12,4)
mov    0x510(%rsp,%r12,1),%ecx
xor    %eax,%ecx
mov    %ecx,0x1c(%rsp,%r12,4)
mov    0x454(%rsp,%r12,1),%ecx
xor    %eax,%ecx
mov    %ecx,0x20(%rsp,%r12,4)
mov    0x494(%rsp,%r12,1),%ecx
xor    %eax,%ecx
mov    %ecx,0x24(%rsp,%r12,4)
mov    0x4d4(%rsp,%r12,1),%ecx
xor    %eax,%ecx
mov    %ecx,0x28(%rsp,%r12,4)
mov    0x514(%rsp,%r12,1),%ecx
xor    %eax,%ecx
mov    %ecx,0x2c(%rsp,%r12,4)
add    $0x8,%r12
cmp    $0x40,%r12d
jne    1370 <calc_4pmk+0x1e0>
lea    0x550(%rsp),%rbx
mov    %rbx,%rdi
call   1080 <shasse2_init@plt>
lea    0x10(%rsp),%rsi
lea    0x840(%rsp),%rdx
mov    %rbx,%rdi
call   1060 <shasse2_data@plt>
xor    %eax,%eax
mov    $0x5c5c5c5c,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x350(%rsp,%rax,1),%edx
xor    %ecx,%edx
mov    %edx,0x10(%rsp,%rax,4)
mov    0x390(%rsp,%rax,1),%edx
xor    %ecx,%edx
mov    %edx,0x14(%rsp,%rax,4)
mov    0x3d0(%rsp,%rax,1),%edx
xor    %ecx,%edx
mov    %edx,0x18(%rsp,%rax,4)
mov    0x410(%rsp,%rax,1),%edx
xor    %ecx,%edx
mov    %edx,0x1c(%rsp,%rax,4)
mov    0x354(%rsp,%rax,1),%edx
xor    %ecx,%edx
mov    %edx,0x20(%rsp,%rax,4)
mov    0x394(%rsp,%rax,1),%edx
xor    %ecx,%edx
mov    %edx,0x24(%rsp,%rax,4)
mov    0x3d4(%rsp,%rax,1),%edx
xor    %ecx,%edx
mov    %edx,0x28(%rsp,%rax,4)
mov    0x414(%rsp,%rax,1),%edx
xor    %ecx,%edx
mov    %edx,0x2c(%rsp,%rax,4)
add    $0x8,%rax
cmp    $0x40,%eax
jne    1430 <calc_4pmk+0x2a0>
lea    0x4(%r13),%eax
mov    %eax,0xc(%rsp)
mov    %r13,%rbp
lea    0x770(%rsp),%r13
mov    %r13,%rdi
call   1080 <shasse2_init@plt>
lea    0x10(%rsp),%rbx
lea    0x840(%rsp),%r15
mov    %r13,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1060 <shasse2_data@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1070 <memset@plt>
movb   $0x80,0x6c(%rsp)
movb   $0x80,0x68(%rsp)
movb   $0x80,0x64(%rsp)
movb   $0x80,0x60(%rsp)
movw   $0xa002,0x10e(%rsp)
movw   $0xa002,0x10a(%rsp)
movw   $0xa002,0x106(%rsp)
movw   $0xa002,0x102(%rsp)
movslq %ebp,%rcx
lea    0x120(%rsp),%r12
mov    %rcx,0x110(%rsp)
movb   $0x1,0x3(%rcx,%r12,1)
xor    %eax,%eax
call   1050 <EVP_sha1@plt>
mov    %eax,%ebp
lea    0x7c0(%rsp),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
movq   $0x0,(%rsp)
lea    0x150(%rsp),%r9
mov    %ebp,%edi
mov    %r14,%rsi
mov    %eax,%edx
mov    %r12,%rcx
mov    0xc(%rsp),%r12d
mov    %r12d,%r8d
call   10a0 <HMAC@plt>
xor    %eax,%eax
call   1050 <EVP_sha1@plt>
mov    %eax,%ebp
lea    0x6a0(%rsp),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
movq   $0x0,(%rsp)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %eax,%edx
lea    0x120(%rsp),%rcx
mov    %r12d,%r8d
lea    0x1d0(%rsp),%r9
call   10a0 <HMAC@plt>
xor    %eax,%eax
call   1050 <EVP_sha1@plt>
mov    %eax,%ebp
lea    0x620(%rsp),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
movq   $0x0,(%rsp)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %eax,%edx
lea    0x120(%rsp),%rcx
mov    %r12d,%r8d
lea    0x250(%rsp),%r9
call   10a0 <HMAC@plt>
xor    %eax,%eax
call   1050 <EVP_sha1@plt>
mov    %eax,%ebp
lea    0x5a0(%rsp),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
movq   $0x0,(%rsp)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %eax,%edx
lea    0x120(%rsp),%rcx
mov    %r12d,%r8d
lea    0x2d0(%rsp),%r9
call   10a0 <HMAC@plt>
mov    0x150(%rsp),%eax
mov    0x154(%rsp),%ecx
mov    %eax,0x10(%rsp)
mov    0x1d0(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    0x250(%rsp),%eax
mov    %eax,0x18(%rsp)
mov    0x2d0(%rsp),%eax
mov    %eax,0x1c(%rsp)
mov    %ecx,0x20(%rsp)
mov    0x1d4(%rsp),%eax
mov    %eax,0x24(%rsp)
mov    0x254(%rsp),%eax
mov    %eax,0x28(%rsp)
mov    0x2d4(%rsp),%eax
mov    %eax,0x2c(%rsp)
mov    0x158(%rsp),%eax
mov    %eax,0x30(%rsp)
mov    0x1d8(%rsp),%eax
mov    %eax,0x34(%rsp)
mov    0x258(%rsp),%eax
mov    %eax,0x38(%rsp)
mov    0x2d8(%rsp),%eax
mov    %eax,0x3c(%rsp)
mov    0x15c(%rsp),%eax
mov    0x160(%rsp),%ecx
mov    %eax,0x40(%rsp)
mov    0x1dc(%rsp),%eax
mov    %eax,0x44(%rsp)
mov    0x25c(%rsp),%eax
mov    %eax,0x48(%rsp)
mov    0x2dc(%rsp),%eax
mov    %eax,0x4c(%rsp)
mov    %ecx,0x50(%rsp)
mov    0x1e0(%rsp),%eax
mov    %eax,0x54(%rsp)
mov    0x260(%rsp),%eax
mov    %eax,0x58(%rsp)
mov    0x2e0(%rsp),%eax
mov    %eax,0x5c(%rsp)
mov    $0xfff,%r12d
lea    0x720(%rsp),%rbp
lea    0x550(%rsp),%r14
nopl   (%rax)
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x50,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1060 <shasse2_data@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   10b0 <shasse2_ends@plt>
mov    %rbp,%rdi
mov    %r13,%rsi
mov    $0x50,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1060 <shasse2_data@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   10b0 <shasse2_ends@plt>
movss  0x20(%rsp),%xmm0
unpcklpd 0x10(%rsp),%xmm0
movss  0x30(%rsp),%xmm1
movss  0x40(%rsp),%xmm2
movlhps %xmm1,%xmm2
shufps $0x22,%xmm2,%xmm0
xorps  0x150(%rsp),%xmm0
movups 0x14(%rsp),%xmm1
movss  0x24(%rsp),%xmm2
movlhps %xmm1,%xmm2
movaps %xmm0,0x150(%rsp)
movss  0x34(%rsp),%xmm0
movss  0x44(%rsp),%xmm1
movlhps %xmm0,%xmm1
movups 0x18(%rsp),%xmm0
shufps $0x22,%xmm1,%xmm2
xorps  0x1d0(%rsp),%xmm2
movups 0x1c(%rsp),%xmm1
movss  0x28(%rsp),%xmm3
movlhps %xmm0,%xmm3
movss  0x38(%rsp),%xmm0
movaps %xmm2,0x1d0(%rsp)
movss  0x2c(%rsp),%xmm2
movss  0x48(%rsp),%xmm4
movlhps %xmm0,%xmm4
movss  0x3c(%rsp),%xmm0
shufps $0x22,%xmm4,%xmm3
xorps  0x250(%rsp),%xmm3
movlhps %xmm1,%xmm2
movaps %xmm3,0x250(%rsp)
movss  0x4c(%rsp),%xmm1
movlhps %xmm0,%xmm1
shufps $0x22,%xmm1,%xmm2
xorps  0x2d0(%rsp),%xmm2
mov    0x50(%rsp),%eax
movaps %xmm2,0x2d0(%rsp)
mov    0x54(%rsp),%ecx
xor    %eax,0x160(%rsp)
mov    0x58(%rsp),%eax
xor    %ecx,0x1e0(%rsp)
mov    0x5c(%rsp),%ecx
xor    %eax,0x260(%rsp)
xor    %ecx,0x2e0(%rsp)
add    $0xffffffff,%r12d
jne    1730 <calc_4pmk+0x5a0>
mov    0x110(%rsp),%rax
movb   $0x2,0x123(%rsp,%rax,1)
02
xor    %eax,%eax
call   1050 <EVP_sha1@plt>
mov    %eax,%ebp
lea    0x7c0(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
lea    0x164(%rsp),%r9
movq   $0x0,(%rsp)
lea    0x120(%rsp),%r14
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %eax,%edx
mov    %r14,%rcx
mov    0xc(%rsp),%ebp
mov    %ebp,%r8d
call   10a0 <HMAC@plt>
xor    %eax,%eax
call   1050 <EVP_sha1@plt>
mov    %eax,%ebx
lea    0x6a0(%rsp),%r15
mov    %r15,%rdi
call   1040 <strlen@plt>
lea    0x1e4(%rsp),%r9
movq   $0x0,(%rsp)
mov    %ebx,%edi
mov    %r15,%rsi
mov    %eax,%edx
mov    %r14,%rcx
mov    %ebp,%r8d
call   10a0 <HMAC@plt>
xor    %eax,%eax
call   1050 <EVP_sha1@plt>
mov    %eax,%ebx
lea    0x620(%rsp),%r15
mov    %r15,%rdi
call   1040 <strlen@plt>
lea    0x264(%rsp),%r9
movq   $0x0,(%rsp)
mov    %ebx,%edi
mov    %r15,%rsi
mov    %eax,%edx
mov    %r14,%rcx
mov    %ebp,%r8d
call   10a0 <HMAC@plt>
xor    %eax,%eax
call   1050 <EVP_sha1@plt>
mov    %eax,%ebx
lea    0x5a0(%rsp),%r15
mov    %r15,%rdi
call   1040 <strlen@plt>
lea    0x2e4(%rsp),%r9
movq   $0x0,(%rsp)
mov    %ebx,%edi
mov    %r15,%rsi
mov    %eax,%edx
mov    %r14,%rcx
mov    %ebp,%r8d
call   10a0 <HMAC@plt>
mov    0x164(%rsp),%eax
mov    0x168(%rsp),%ecx
mov    %eax,0x10(%rsp)
mov    0x1e4(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    0x264(%rsp),%eax
mov    %eax,0x18(%rsp)
mov    0x2e4(%rsp),%eax
mov    %eax,0x1c(%rsp)
mov    %ecx,0x20(%rsp)
mov    0x1e8(%rsp),%eax
mov    %eax,0x24(%rsp)
mov    0x268(%rsp),%eax
mov    %eax,0x28(%rsp)
mov    0x2e8(%rsp),%eax
mov    %eax,0x2c(%rsp)
mov    0x16c(%rsp),%eax
mov    %eax,0x30(%rsp)
mov    0x1ec(%rsp),%eax
mov    %eax,0x34(%rsp)
mov    0x26c(%rsp),%eax
mov    %eax,0x38(%rsp)
mov    0x2ec(%rsp),%eax
mov    %eax,0x3c(%rsp)
mov    0x170(%rsp),%eax
mov    0x174(%rsp),%ecx
mov    %eax,0x40(%rsp)
mov    0x1f0(%rsp),%eax
mov    %eax,0x44(%rsp)
mov    0x270(%rsp),%eax
mov    %eax,0x48(%rsp)
mov    0x2f0(%rsp),%eax
mov    %eax,0x4c(%rsp)
mov    %ecx,0x50(%rsp)
mov    0x1f4(%rsp),%eax
mov    %eax,0x54(%rsp)
mov    0x274(%rsp),%eax
mov    %eax,0x58(%rsp)
mov    0x2f4(%rsp),%eax
mov    %eax,0x5c(%rsp)
mov    $0xfff,%ebp
lea    0x720(%rsp),%rbx
lea    0x550(%rsp),%r14
lea    0x10(%rsp),%r13
lea    0x840(%rsp),%r15
lea    0x770(%rsp),%r12
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x50,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
call   1060 <shasse2_data@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
call   10b0 <shasse2_ends@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    $0x50,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
call   1060 <shasse2_data@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
call   10b0 <shasse2_ends@plt>
mov    0x10(%rsp),%eax
mov    0x14(%rsp),%ecx
xor    %eax,0x164(%rsp)
xor    %ecx,0x1e4(%rsp)
mov    0x18(%rsp),%eax
xor    %eax,0x264(%rsp)
mov    0x1c(%rsp),%eax
xor    %eax,0x2e4(%rsp)
mov    0x20(%rsp),%eax
xor    %eax,0x168(%rsp)
mov    0x24(%rsp),%eax
xor    %eax,0x1e8(%rsp)
mov    0x28(%rsp),%eax
xor    %eax,0x268(%rsp)
mov    0x2c(%rsp),%eax
xor    %eax,0x2e8(%rsp)
mov    0x30(%rsp),%eax
xor    %eax,0x16c(%rsp)
mov    0x34(%rsp),%eax
xor    %eax,0x1ec(%rsp)
mov    0x38(%rsp),%eax
xor    %eax,0x26c(%rsp)
mov    0x3c(%rsp),%eax
xor    %eax,0x2ec(%rsp)
add    $0xffffffff,%ebp
jne    1a90 <calc_4pmk+0x900>
mov    0xd88(%rsp),%rdi
lea    0x250(%rsp),%rsi
mov    $0x20,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
mov    0xd90(%rsp),%rdi
lea    0x2d0(%rsp),%rsi
mov    $0x20,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
lea    0x150(%rsp),%rsi
mov    0x118(%rsp),%rdi
mov    $0x20,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
mov    0xd80(%rsp),%rdi
lea    0x1d0(%rsp),%rsi
mov    $0x20,%edx
xor    %eax,%eax
call   1090 <memcpy@plt>
add    $0xd48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @calc_4pmk(i8* %0, i8* %1, i8* %2, i8* %3, i8* %4, i8* %5, i8* %6, i8* %7, i8* %8) {
%10 = alloca [36 x i8]
%11 = alloca [128 x i8]
%12 = alloca [128 x i8]
%13 = alloca [128 x i8]
%14 = alloca [128 x i8]
%15 = alloca [512 x i8]
%16 = alloca [256 x i8]
%17 = alloca [80 x i8]
%18 = alloca [256 x i8]
%19 = alloca [80 x i8]
%20 = alloca [256 x i8]
%21 = alloca [80 x i8]
%22 = alloca [1280 x i8]
%23 = getelementptr inbounds [36 x i8], [36 x i8]* %10, i64 0, i64 0
%24 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 0
%25 = getelementptr inbounds [128 x i8], [128 x i8]* %12, i64 0, i64 0
%26 = getelementptr inbounds [128 x i8], [128 x i8]* %13, i64 0, i64 0
%27 = getelementptr inbounds [128 x i8], [128 x i8]* %14, i64 0, i64 0
%28 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 0
%29 = getelementptr inbounds [256 x i8], [256 x i8]* %16, i64 0, i64 0
%30 = getelementptr inbounds [80 x i8], [80 x i8]* %17, i64 0, i64 0
%31 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%32 = getelementptr inbounds [80 x i8], [80 x i8]* %19, i64 0, i64 0
%33 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 0
%34 = getelementptr inbounds [80 x i8], [80 x i8]* %21, i64 0, i64 0
%35 = getelementptr inbounds [1280 x i8], [1280 x i8]* %22, i64 0, i64 0
%36 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 256
%37 = call i32 @strncpy(i8* %23, i8* %4, i32 35)
%38 = call i32 @strncpy(i8* %24, i8* %0, i32 127)
%39 = call i32 @strncpy(i8* %25, i8* %1, i32 127)
%40 = call i32 @strncpy(i8* %26, i8* %2, i32 127)
%41 = call i32 @strncpy(i8* %27, i8* %3, i32 127)
%42 = call i32 @strlen(i8* %23)
%43 = call i32 @memset(i8* %29, i32 0, i32 256)
%44 = call i32 @memset(i8* %31, i32 0, i32 256)
%45 = call i32 @strlen(i8* %24)
%46 = call i32 (i8*, ...) @memcpy(i8* %29, i8* %24, i32 %45)
%47 = call i32 @strlen(i8* %24)
%48 = call i32 (i8*, ...) @memcpy(i8* %31, i8* %24, i32 %47)
%49 = getelementptr inbounds [256 x i8], [256 x i8]* %16, i64 0, i64 64
%50 = call i32 @strlen(i8* %25)
%51 = call i32 (i8*, ...) @memcpy(i8* %49, i8* %25, i32 %50)
%52 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 64
%53 = call i32 @strlen(i8* %25)
%54 = call i32 (i8*, ...) @memcpy(i8* %52, i8* %25, i32 %53)
%55 = getelementptr inbounds [256 x i8], [256 x i8]* %16, i64 0, i64 128
%56 = call i32 @strlen(i8* %26)
%57 = call i32 (i8*, ...) @memcpy(i8* %55, i8* %26, i32 %56)
%58 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 128
%59 = call i32 @strlen(i8* %26)
%60 = call i32 (i8*, ...) @memcpy(i8* %58, i8* %26, i32 %59)
%61 = getelementptr inbounds [256 x i8], [256 x i8]* %16, i64 0, i64 192
%62 = call i32 @strlen(i8* %27)
%63 = call i32 (i8*, ...) @memcpy(i8* %61, i8* %27, i32 %62)
%64 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 192
%65 = call i32 @strlen(i8* %27)
%66 = call i32 (i8*, ...) @memcpy(i8* %64, i8* %27, i32 %65)
%67 = bitcast [256 x i8]* %16 to i32*
%68 = bitcast i8* %49 to i32*
%69 = bitcast i8* %55 to i32*
%70 = bitcast i8* %61 to i32*
%71 = bitcast [256 x i8]* %20 to i32*
br label %72
72: ; preds = %72, %9
%73 = phi i32 [ 0, %9 ], [ %111, %72 ]
%74 = phi i32* [ %67, %9 ], [ %95, %72 ]
%75 = phi i32* [ %68, %9 ], [ %99, %72 ]
%76 = phi i32* [ %71, %9 ], [ %110, %72 ]
%77 = phi i32* [ %70, %9 ], [ %107, %72 ]
%78 = phi i32* [ %69, %9 ], [ %103, %72 ]
%79 = getelementptr inbounds i32, i32* %74, i64 1
%80 = load i32, i32* %74
%81 = xor i32 %80, 909522486
%82 = getelementptr inbounds i32, i32* %76, i64 1
store i32 %81, i32* %76
%83 = getelementptr inbounds i32, i32* %75, i64 1
%84 = load i32, i32* %75
%85 = xor i32 %84, 909522486
%86 = getelementptr inbounds i32, i32* %76, i64 2
store i32 %85, i32* %82
%87 = getelementptr inbounds i32, i32* %78, i64 1
%88 = load i32, i32* %78
%89 = xor i32 %88, 909522486
%90 = getelementptr inbounds i32, i32* %76, i64 3
store i32 %89, i32* %86
%91 = getelementptr inbounds i32, i32* %77, i64 1
%92 = load i32, i32* %77
%93 = xor i32 %92, 909522486
%94 = getelementptr inbounds i32, i32* %76, i64 4
store i32 %93, i32* %90
%95 = getelementptr inbounds i32, i32* %74, i64 2
%96 = load i32, i32* %79
%97 = xor i32 %96, 909522486
%98 = getelementptr inbounds i32, i32* %76, i64 5
store i32 %97, i32* %94
%99 = getelementptr inbounds i32, i32* %75, i64 2
%100 = load i32, i32* %83
%101 = xor i32 %100, 909522486
%102 = getelementptr inbounds i32, i32* %76, i64 6
store i32 %101, i32* %98
%103 = getelementptr inbounds i32, i32* %78, i64 2
%104 = load i32, i32* %87
%105 = xor i32 %104, 909522486
%106 = getelementptr inbounds i32, i32* %76, i64 7
store i32 %105, i32* %102
%107 = getelementptr inbounds i32, i32* %77, i64 2
%108 = load i32, i32* %91
%109 = xor i32 %108, 909522486
%110 = getelementptr inbounds i32, i32* %76, i64 8
store i32 %109, i32* %106
%111 = add nuw nsw i32 %73, 2
%112 = icmp eq i32 %111, 16
br i1 %112, label %113, label %72
113: ; preds = %72
%114 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 384
%115 = call i32 @shasse2_init(i8* %30)
%116 = call i32 @shasse2_data(i8* %30, i8* %33, i8* %35)
%117 = bitcast [256 x i8]* %18 to i32*
%118 = bitcast i8* %52 to i32*
%119 = bitcast i8* %58 to i32*
%120 = bitcast i8* %64 to i32*
br label %121
121: ; preds = %121, %113
%122 = phi i32 [ 0, %113 ], [ %160, %121 ]
%123 = phi i32* [ %117, %113 ], [ %144, %121 ]
%124 = phi i32* [ %118, %113 ], [ %148, %121 ]
%125 = phi i32* [ %71, %113 ], [ %159, %121 ]
%126 = phi i32* [ %120, %113 ], [ %156, %121 ]
%127 = phi i32* [ %119, %113 ], [ %152, %121 ]
%128 = getelementptr inbounds i32, i32* %123, i64 1
%129 = load i32, i32* %123
%130 = xor i32 %129, 1549556828
%131 = getelementptr inbounds i32, i32* %125, i64 1
store i32 %130, i32* %125
%132 = getelementptr inbounds i32, i32* %124, i64 1
%133 = load i32, i32* %124
%134 = xor i32 %133, 1549556828
%135 = getelementptr inbounds i32, i32* %125, i64 2
store i32 %134, i32* %131
%136 = getelementptr inbounds i32, i32* %127, i64 1
%137 = load i32, i32* %127
%138 = xor i32 %137, 1549556828
%139 = getelementptr inbounds i32, i32* %125, i64 3
store i32 %138, i32* %135
%140 = getelementptr inbounds i32, i32* %126, i64 1
%141 = load i32, i32* %126
%142 = xor i32 %141, 1549556828
%143 = getelementptr inbounds i32, i32* %125, i64 4
store i32 %142, i32* %139
%144 = getelementptr inbounds i32, i32* %123, i64 2
%145 = load i32, i32* %128
%146 = xor i32 %145, 1549556828
%147 = getelementptr inbounds i32, i32* %125, i64 5
store i32 %146, i32* %143
%148 = getelementptr inbounds i32, i32* %124, i64 2
%149 = load i32, i32* %132
%150 = xor i32 %149, 1549556828
%151 = getelementptr inbounds i32, i32* %125, i64 6
store i32 %150, i32* %147
%152 = getelementptr inbounds i32, i32* %127, i64 2
%153 = load i32, i32* %136
%154 = xor i32 %153, 1549556828
%155 = getelementptr inbounds i32, i32* %125, i64 7
store i32 %154, i32* %151
%156 = getelementptr inbounds i32, i32* %126, i64 2
%157 = load i32, i32* %140
%158 = xor i32 %157, 1549556828
%159 = getelementptr inbounds i32, i32* %125, i64 8
store i32 %158, i32* %155
%160 = add nuw nsw i32 %122, 2
%161 = icmp eq i32 %160, 16
br i1 %161, label %162, label %121
162: ; preds = %121
%163 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 128
%164 = add nsw i32 %42, 4
%165 = call i32 @shasse2_init(i8* %32)
%166 = call i32 @shasse2_data(i8* %32, i8* %33, i8* %35)
%167 = call i32 @memset(i8* %33, i32 0, i32 256)
%168 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 92
store i8 -128, i8* %168
%169 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 88
store i8 -128, i8* %169
%170 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 84
store i8 -128, i8* %170
%171 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 80
store i8 -128, i8* %171
%172 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 254
store i8 2, i8* %172
%173 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 250
store i8 2, i8* %173
%174 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 246
store i8 2, i8* %174
%175 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 242
store i8 2, i8* %175
%176 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 255
store i8 -96, i8* %176
%177 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 251
store i8 -96, i8* %177
%178 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 247
store i8 -96, i8* %178
%179 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 243
store i8 -96, i8* %179
%180 = add nsw i32 %42, 3
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [36 x i8], [36 x i8]* %10, i64 0, i64 %181
store i8 1, i8* %182
%183 = call i32 (...) @EVP_sha1()
%184 = call i32 @strlen(i8* %24)
%185 = call i32 @HMAC(i32 %183, i8* %24, i32 %184, i8* %23, i32 %164, i8* %28, i32* null)
%186 = call i32 (...) @EVP_sha1()
%187 = call i32 @strlen(i8* %25)
%188 = call i32 @HMAC(i32 %186, i8* %25, i32 %187, i8* %23, i32 %164, i8* %163, i32* null)
%189 = call i32 (...) @EVP_sha1()
%190 = call i32 @strlen(i8* %26)
%191 = call i32 @HMAC(i32 %189, i8* %26, i32 %190, i8* %23, i32 %164, i8* %36, i32* null)
%192 = call i32 (...) @EVP_sha1()
%193 = call i32 @strlen(i8* %27)
%194 = call i32 @HMAC(i32 %192, i8* %27, i32 %193, i8* %23, i32 %164, i8* %114, i32* null)
%195 = bitcast [512 x i8]* %15 to i32*
%196 = bitcast i8* %163 to i32*
%197 = bitcast i8* %36 to i32*
%198 = bitcast i8* %114 to i32*
%199 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 4
%200 = bitcast i8* %199 to i32*
%201 = load i32, i32* %195
%202 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 4
%203 = bitcast i8* %202 to i32*
store i32 %201, i32* %71
%204 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 132
%205 = bitcast i8* %204 to i32*
%206 = load i32, i32* %196
%207 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 8
%208 = bitcast i8* %207 to i32*
store i32 %206, i32* %203
%209 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 260
%210 = bitcast i8* %209 to i32*
%211 = load i32, i32* %197
%212 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 12
%213 = bitcast i8* %212 to i32*
store i32 %211, i32* %208
%214 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 388
%215 = bitcast i8* %214 to i32*
%216 = load i32, i32* %198
%217 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 16
%218 = bitcast i8* %217 to i32*
store i32 %216, i32* %213
%219 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 8
%220 = bitcast i8* %219 to i32*
%221 = load i32, i32* %200
%222 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 20
%223 = bitcast i8* %222 to i32*
store i32 %221, i32* %218
%224 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 136
%225 = bitcast i8* %224 to i32*
%226 = load i32, i32* %205
%227 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 24
%228 = bitcast i8* %227 to i32*
store i32 %226, i32* %223
%229 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 264
%230 = bitcast i8* %229 to i32*
%231 = load i32, i32* %210
%232 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 28
%233 = bitcast i8* %232 to i32*
store i32 %231, i32* %228
%234 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 392
%235 = bitcast i8* %234 to i32*
%236 = load i32, i32* %215
%237 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 32
%238 = bitcast i8* %237 to i32*
store i32 %236, i32* %233
%239 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 12
%240 = bitcast i8* %239 to i32*
%241 = load i32, i32* %220
%242 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 36
%243 = bitcast i8* %242 to i32*
store i32 %241, i32* %238
%244 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 140
%245 = bitcast i8* %244 to i32*
%246 = load i32, i32* %225
%247 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 40
%248 = bitcast i8* %247 to i32*
store i32 %246, i32* %243
%249 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 268
%250 = bitcast i8* %249 to i32*
%251 = load i32, i32* %230
%252 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 44
%253 = bitcast i8* %252 to i32*
store i32 %251, i32* %248
%254 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 396
%255 = bitcast i8* %254 to i32*
%256 = load i32, i32* %235
%257 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 48
%258 = bitcast i8* %257 to i32*
store i32 %256, i32* %253
%259 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 16
%260 = bitcast i8* %259 to i32*
%261 = load i32, i32* %240
%262 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 52
%263 = bitcast i8* %262 to i32*
store i32 %261, i32* %258
%264 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 144
%265 = bitcast i8* %264 to i32*
%266 = load i32, i32* %245
%267 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 56
%268 = bitcast i8* %267 to i32*
store i32 %266, i32* %263
%269 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 272
%270 = bitcast i8* %269 to i32*
%271 = load i32, i32* %250
%272 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 60
%273 = bitcast i8* %272 to i32*
store i32 %271, i32* %268
%274 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 400
%275 = bitcast i8* %274 to i32*
%276 = load i32, i32* %255
%277 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 64
%278 = bitcast i8* %277 to i32*
store i32 %276, i32* %273
%279 = load i32, i32* %260
%280 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 68
%281 = bitcast i8* %280 to i32*
store i32 %279, i32* %278
%282 = load i32, i32* %265
%283 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 72
%284 = bitcast i8* %283 to i32*
store i32 %282, i32* %281
%285 = load i32, i32* %270
%286 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 76
%287 = bitcast i8* %286 to i32*
store i32 %285, i32* %284
%288 = load i32, i32* %275
store i32 %288, i32* %287
%289 = bitcast [256 x i8]* %20 to <4 x i32>*
%290 = bitcast i8* %202 to <4 x i32>*
%291 = bitcast i8* %207 to <4 x i32>*
%292 = bitcast i8* %212 to <4 x i32>*
%293 = bitcast [512 x i8]* %15 to <4 x i32>*
%294 = bitcast [512 x i8]* %15 to <4 x i32>*
%295 = bitcast i8* %163 to <4 x i32>*
%296 = bitcast i8* %163 to <4 x i32>*
%297 = bitcast i8* %36 to <4 x i32>*
%298 = bitcast i8* %36 to <4 x i32>*
%299 = bitcast i8* %114 to <4 x i32>*
%300 = bitcast i8* %114 to <4 x i32>*
br label %301
301: ; preds = %162, %301
%302 = phi i32 [ 1, %162 ], [ %357, %301 ]
%303 = call i32 (i8*, ...) @memcpy(i8* %34, i8* %30, i32 80)
%304 = call i32 @shasse2_data(i8* %34, i8* %33, i8* %35)
%305 = call i32 @shasse2_ends(i8* %34, i8* %33)
%306 = call i32 (i8*, ...) @memcpy(i8* %34, i8* %32, i32 80)
%307 = call i32 @shasse2_data(i8* %34, i8* %33, i8* %35)
%308 = call i32 @shasse2_ends(i8* %34, i8* %33)
%309 = load <4 x i32>, <4 x i32>* %289
%310 = load <4 x i32>, <4 x i32>* %290
%311 = load <4 x i32>, <4 x i32>* %291
%312 = load <4 x i32>, <4 x i32>* %292
%313 = load i32, i32* %218
%314 = load i32, i32* %223
%315 = load i32, i32* %228
%316 = load i32, i32* %233
%317 = load i32, i32* %238
%318 = load i32, i32* %243
%319 = load i32, i32* %248
%320 = load i32, i32* %253
%321 = load i32, i32* %258
%322 = load <4 x i32>, <4 x i32>* %293
%323 = insertelement <4 x i32> %309, i32 %313, i64 1
%324 = insertelement <4 x i32> %323, i32 %317, i64 2
%325 = insertelement <4 x i32> %324, i32 %321, i64 3
%326 = xor <4 x i32> %322, %325
store <4 x i32> %326, <4 x i32>* %294
%327 = load i32, i32* %263
%328 = load <4 x i32>, <4 x i32>* %295
%329 = insertelement <4 x i32> %310, i32 %314, i64 1
%330 = insertelement <4 x i32> %329, i32 %318, i64 2
%331 = insertelement <4 x i32> %330, i32 %327, i64 3
%332 = xor <4 x i32> %328, %331
store <4 x i32> %332, <4 x i32>* %296
%333 = load i32, i32* %268
%334 = load <4 x i32>, <4 x i32>* %297
%335 = insertelement <4 x i32> %311, i32 %315, i64 1
%336 = insertelement <4 x i32> %335, i32 %319, i64 2
%337 = insertelement <4 x i32> %336, i32 %333, i64 3
%338 = xor <4 x i32> %334, %337
store <4 x i32> %338, <4 x i32>* %298
%339 = load i32, i32* %273
%340 = load <4 x i32>, <4 x i32>* %299
%341 = insertelement <4 x i32> %312, i32 %316, i64 1
%342 = insertelement <4 x i32> %341, i32 %320, i64 2
%343 = insertelement <4 x i32> %342, i32 %339, i64 3
%344 = xor <4 x i32> %340, %343
store <4 x i32> %344, <4 x i32>* %300
%345 = load i32, i32* %278
%346 = load i32, i32* %260
%347 = xor i32 %346, %345
store i32 %347, i32* %260
%348 = load i32, i32* %281
%349 = load i32, i32* %265
%350 = xor i32 %349, %348
store i32 %350, i32* %265
%351 = load i32, i32* %284
%352 = load i32, i32* %270
%353 = xor i32 %352, %351
store i32 %353, i32* %270
%354 = load i32, i32* %287
%355 = load i32, i32* %275
%356 = xor i32 %355, %354
store i32 %356, i32* %275
%357 = add nuw nsw i32 %302, 1
%358 = icmp eq i32 %357, 4096
br i1 %358, label %359, label %301
359: ; preds = %301
store i8 2, i8* %182
%360 = call i32 (...) @EVP_sha1()
%361 = call i32 @strlen(i8* %24)
%362 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 20
%363 = call i32 @HMAC(i32 %360, i8* %24, i32 %361, i8* %23, i32 %164, i8* %362, i32* null)
%364 = call i32 (...) @EVP_sha1()
%365 = call i32 @strlen(i8* %25)
%366 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 148
%367 = call i32 @HMAC(i32 %364, i8* %25, i32 %365, i8* %23, i32 %164, i8* %366, i32* null)
%368 = call i32 (...) @EVP_sha1()
%369 = call i32 @strlen(i8* %26)
%370 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 276
%371 = call i32 @HMAC(i32 %368, i8* %26, i32 %369, i8* %23, i32 %164, i8* %370, i32* null)
%372 = call i32 (...) @EVP_sha1()
%373 = call i32 @strlen(i8* %27)
%374 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 404
%375 = call i32 @HMAC(i32 %372, i8* %27, i32 %373, i8* %23, i32 %164, i8* %374, i32* null)
%376 = bitcast i8* %362 to i32*
%377 = bitcast i8* %366 to i32*
%378 = bitcast i8* %370 to i32*
%379 = bitcast i8* %374 to i32*
%380 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 24
%381 = bitcast i8* %380 to i32*
%382 = load i32, i32* %376
store i32 %382, i32* %71
%383 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 152
%384 = bitcast i8* %383 to i32*
%385 = load i32, i32* %377
store i32 %385, i32* %203
%386 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 280
%387 = bitcast i8* %386 to i32*
%388 = load i32, i32* %378
store i32 %388, i32* %208
%389 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 408
%390 = bitcast i8* %389 to i32*
%391 = load i32, i32* %379
store i32 %391, i32* %213
%392 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 28
%393 = bitcast i8* %392 to i32*
%394 = load i32, i32* %381
store i32 %394, i32* %218
%395 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 156
%396 = bitcast i8* %395 to i32*
%397 = load i32, i32* %384
store i32 %397, i32* %223
%398 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 284
%399 = bitcast i8* %398 to i32*
%400 = load i32, i32* %387
store i32 %400, i32* %228
%401 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 412
%402 = bitcast i8* %401 to i32*
%403 = load i32, i32* %390
store i32 %403, i32* %233
%404 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 32
%405 = bitcast i8* %404 to i32*
%406 = load i32, i32* %393
store i32 %406, i32* %238
%407 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 160
%408 = bitcast i8* %407 to i32*
%409 = load i32, i32* %396
store i32 %409, i32* %243
%410 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 288
%411 = bitcast i8* %410 to i32*
%412 = load i32, i32* %399
store i32 %412, i32* %248
%413 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 416
%414 = bitcast i8* %413 to i32*
%415 = load i32, i32* %402
store i32 %415, i32* %253
%416 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 36
%417 = bitcast i8* %416 to i32*
%418 = load i32, i32* %405
store i32 %418, i32* %258
%419 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 164
%420 = bitcast i8* %419 to i32*
%421 = load i32, i32* %408
store i32 %421, i32* %263
%422 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 292
%423 = bitcast i8* %422 to i32*
%424 = load i32, i32* %411
store i32 %424, i32* %268
%425 = getelementptr inbounds [512 x i8], [512 x i8]* %15, i64 0, i64 420
%426 = bitcast i8* %425 to i32*
%427 = load i32, i32* %414
store i32 %427, i32* %273
%428 = load i32, i32* %417
store i32 %428, i32* %278
%429 = load i32, i32* %420
store i32 %429, i32* %281
%430 = load i32, i32* %423
store i32 %430, i32* %284
%431 = load i32, i32* %426
store i32 %431, i32* %287
br label %432
432: ; preds = %359, %432
%433 = phi i32 [ 1, %359 ], [ %476, %432 ]
%434 = call i32 (i8*, ...) @memcpy(i8* %34, i8* %30, i32 80)
%435 = call i32 @shasse2_data(i8* %34, i8* %33, i8* %35)
%436 = call i32 @shasse2_ends(i8* %34, i8* %33)
%437 = call i32 (i8*, ...) @memcpy(i8* %34, i8* %32, i32 80)
%438 = call i32 @shasse2_data(i8* %34, i8* %33, i8* %35)
%439 = call i32 @shasse2_ends(i8* %34, i8* %33)
%440 = load i32, i32* %71
%441 = load i32, i32* %376
%442 = xor i32 %441, %440
store i32 %442, i32* %376
%443 = load i32, i32* %203
%444 = load i32, i32* %377
%445 = xor i32 %444, %443
store i32 %445, i32* %377
%446 = load i32, i32* %208
%447 = load i32, i32* %378
%448 = xor i32 %447, %446
store i32 %448, i32* %378
%449 = load i32, i32* %213
%450 = load i32, i32* %379
%451 = xor i32 %450, %449
store i32 %451, i32* %379
%452 = load i32, i32* %218
%453 = load i32, i32* %381
%454 = xor i32 %453, %452
store i32 %454, i32* %381
%455 = load i32, i32* %223
%456 = load i32, i32* %384
%457 = xor i32 %456, %455
store i32 %457, i32* %384
%458 = load i32, i32* %228
%459 = load i32, i32* %387
%460 = xor i32 %459, %458
store i32 %460, i32* %387
%461 = load i32, i32* %233
%462 = load i32, i32* %390
%463 = xor i32 %462, %461
store i32 %463, i32* %390
%464 = load i32, i32* %238
%465 = load i32, i32* %393
%466 = xor i32 %465, %464
store i32 %466, i32* %393
%467 = load i32, i32* %243
%468 = load i32, i32* %396
%469 = xor i32 %468, %467
store i32 %469, i32* %396
%470 = load i32, i32* %248
%471 = load i32, i32* %399
%472 = xor i32 %471, %470
store i32 %472, i32* %399
%473 = load i32, i32* %253
%474 = load i32, i32* %402
%475 = xor i32 %474, %473
store i32 %475, i32* %402
%476 = add nuw nsw i32 %433, 1
%477 = icmp eq i32 %476, 4096
br i1 %477, label %478, label %432
478: ; preds = %432
%479 = call i32 (i8*, ...) @memcpy(i8* %7, i8* %36, i32 32)
%480 = call i32 (i8*, ...) @memcpy(i8* %8, i8* %114, i32 32)
%481 = call i32 (i8*, ...) @memcpy(i8* %5, i8* %28, i32 32)
%482 = call i32 (i8*, ...) @memcpy(i8* %6, i8* %163, i32 32)
ret void
}