int keypair(unsigned char *sk, unsigned char *pk) {
  unsigned char S[64 * 64], INVS[64 * 64], ST[64 * 64];
  unsigned char M[64 * 64], U[64 * 64], V[64 * 64];
  unsigned char T[128 * 128], INVT[128 * 128];
  unsigned char B[8 * 8 * 64], C[8 * 8 * 64], A[8 * 8 * 64];
  unsigned char TEMPA[8 * 64], TEMPB[8 * 64], TEMPC[8 * 64], TEMPF[2080];
  unsigned char *F;
  unsigned char *FB;
  int i, j, s, t, ij = 0, eof, count, flag = 0;
  unsigned char W = 0;
  F = (unsigned char *)malloc(((8 * 8 + 8 * 8) * 2080) * sizeof(unsigned char));
  FB = (unsigned char *)malloc(((8 * 8 + 8 * 8) * 2080) *
                               (sizeof(unsigned char)));
  printf("************************************************* \n");
  printf("Start ABC key pair generation \n");
  printf("************************************************* \n");
  eof = 0;
  while (eof == 0) {
    for (i = 0; i < 64; i++) {
      for (j = 0; j < 64; j++) {
        INVS[i * 64 + j] = S[i * 64 + j] = rand() % 256;
      }
    }
    eof = matrixinv(INVS, 64);
  }
  eof = 0;
  while (eof == 0) {
    for (i = 0; i < 128; i++) {
      for (j = 0; j < 128; j++) {
        INVT[i * 128 + j] = T[i * 128 + j] = rand() % 256;
      }
    }
    eof = matrixinv(INVT, 128);
  }
  for (i = 0; i < 128; i++) {
    for (j = 0; j < 128; j++) {
      sk[ij++] = INVT[i * 128 + j];
    }
  }
  for (i = 0; i < 8 * 8 * 64; i++) {
    A[i] = rand() % 256;
  }
  for (i = 0; i < 8 * 8 * 64; i++) {
    sk[ij++] = B[i] = rand() % 256;
  }
  for (i = 0; i < 8 * 8 * 64; i++) {
    sk[ij++] = C[i] = rand() % 256;
  }
  count = 0;
  flag = 0;
  for (i = 0; i < 8; i++) {
    for (j = 0; j < 8 * 64; j++) {
      TEMPA[j] = A[i * 8 * 64 + j];
    }
    for (j = 0; j < 8; j++) {
      for (s = 0; s < 8; s++) {
        for (t = 0; t < 64; t++) {
          TEMPB[s * 64 + t] = B[j * 64 + s * 8 * 64 + t];
        }
      }
      tensorproduct(TEMPA, TEMPB, TEMPF, 64, 8);
      for (s = 0; s < 64; s++) {
        for (t = s; t < 64; t++) {
          sk[ij++] = F[flag++] = TEMPF[count++];
        }
      }
      count = 0;
    }
  }
  for (i = 0; i < 8; i++) {
    for (s = 0; s < 8; s++) {
      for (t = 0; t < 64; t++) {
        TEMPA[s * 64 + t] = A[i * 8 * 64 + s * 64 + t];
      }
    }
    for (j = 0; j < 8; j++) {
      for (s = 0; s < 8; s++) {
        for (t = 0; t < 64; t++) {
          TEMPC[s * 64 + t] = C[j * 64 + s * 8 * 64 + t];
        }
      }
      tensorproduct(TEMPA, TEMPC, TEMPF, 64, 8);
      for (s = 0; s < 64; s++) {
        for (t = s; t < 64; t++) {
          sk[ij++] = F[flag++] = TEMPF[count++];
        }
      }
      count = 0;
    }
  }
  matrixtranspose(S, 64, ST);
  count = 0;
  flag = 0;
  int num = 0;
  for (i = 0; i < 8 * (8 + 8); i++) {
    for (s = 0; s < 64 * 64; s++) {
      M[s] = (unsigned char)0;
    }
    for (s = 0; s < 64; s++) {
      for (t = s; t < 64; t++) {
        M[s * 64 + t] = F[count++];
      }
    }
    matrixmul(ST, M, 64, 64, 64, U);
    matrixmul(U, S, 64, 64, 64, V);
    for (s = 0; s < 64; s++) {
      for (t = s; t < 64; t++) {
        if (t == s) {
          FB[flag++] = V[s * 64 + t];
        }
        if (t != s) {
          FB[flag++] =
              add((unsigned char)V[s * 64 + t], (unsigned char)V[t * 64 + s]);
        }
      }
    }
  }
  matrixmul(T, FB, 128, 128, 2080, pk);
  for (i = 0; i < 64; i++) {
    for (j = 0; j < 64; j++) {
      sk[ij++] = INVS[i * 64 + j];
    }
  }
  free(F);
  free(FB);
  return (1);
}


x86 assembly (clang, -O0):
<keypair>:
push   %rbp
mov    %rsp,%rbp
sub    $0x11e70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x11e54(%rbp)
movl   $0x0,-0x11e60(%rbp)
movb   $0x0,-0x11e61(%rbp)
mov    $0x41000,%edi
call   1080 <malloc@plt>
mov    %rax,-0x11e38(%rbp)
mov    $0x41000,%edi
call   1080 <malloc@plt>
mov    %rax,-0x11e40(%rbp)
lea    0xe19(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xe3f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xdfd(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x11e58(%rbp)
cmpl   $0x0,-0x11e58(%rbp)
jne    12db <keypair+0x14b>
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x40,-0x11e44(%rbp)
jge    12bd <keypair+0x12d>
movl   $0x0,-0x11e48(%rbp)
cmpl   $0x40,-0x11e48(%rbp)
jge    12a4 <keypair+0x114>
mov    $0x0,%al
call   10b0 <rand@plt>
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %dl,%cl
mov    -0x11e44(%rbp),%eax
shl    $0x6,%eax
add    -0x11e48(%rbp),%eax
cltq
mov    %cl,-0x1010(%rbp,%rax,1)
mov    -0x11e44(%rbp),%eax
shl    $0x6,%eax
add    -0x11e48(%rbp),%eax
cltq
mov    %cl,-0x2010(%rbp,%rax,1)
mov    -0x11e48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e48(%rbp)
jmp    1242 <keypair+0xb2>
jmp    12a9 <keypair+0x119>
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    122b <keypair+0x9b>
lea    -0x2010(%rbp),%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1090 <matrixinv@plt>
mov    %eax,-0x11e58(%rbp)
jmp    1214 <keypair+0x84>
movl   $0x0,-0x11e58(%rbp)
cmpl   $0x0,-0x11e58(%rbp)
jne    13b2 <keypair+0x222>
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x80,-0x11e44(%rbp)
jge    1394 <keypair+0x204>
movl   $0x0,-0x11e48(%rbp)
cmpl   $0x80,-0x11e48(%rbp)
jge    137b <keypair+0x1eb>
mov    $0x0,%al
call   10b0 <rand@plt>
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %dl,%cl
mov    -0x11e44(%rbp),%eax
shl    $0x7,%eax
add    -0x11e48(%rbp),%eax
cltq
mov    %cl,-0xa010(%rbp,%rax,1)
mov    -0x11e44(%rbp),%eax
shl    $0x7,%eax
add    -0x11e48(%rbp),%eax
cltq
mov    %cl,-0xe010(%rbp,%rax,1)
mov    -0x11e48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e48(%rbp)
jmp    1316 <keypair+0x186>
jmp    1380 <keypair+0x1f0>
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    12fc <keypair+0x16c>
lea    -0xe010(%rbp),%rdi
mov    $0x80,%esi
mov    $0x0,%al
call   1090 <matrixinv@plt>
mov    %eax,-0x11e58(%rbp)
jmp    12e5 <keypair+0x155>
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x80,-0x11e44(%rbp)
jge    1446 <keypair+0x2b6>
movl   $0x0,-0x11e48(%rbp)
cmpl   $0x80,-0x11e48(%rbp)
jge    142d <keypair+0x29d>
mov    -0x11e44(%rbp),%eax
shl    $0x7,%eax
add    -0x11e48(%rbp),%eax
cltq
mov    -0xe010(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x11e54(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e54(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x11e48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e48(%rbp)
jmp    13d6 <keypair+0x246>
jmp    1432 <keypair+0x2a2>
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    13bc <keypair+0x22c>
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x1000,-0x11e44(%rbp)
jge    1493 <keypair+0x303>
mov    $0x0,%al
call   10b0 <rand@plt>
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %dl,%cl
movslq -0x11e44(%rbp),%rax
mov    %cl,-0x11010(%rbp,%rax,1)
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    1450 <keypair+0x2c0>
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x1000,-0x11e44(%rbp)
jge    14f9 <keypair+0x369>
mov    $0x0,%al
call   10b0 <rand@plt>
mov    $0x100,%ecx
cltd
idiv   %ecx
movslq -0x11e44(%rbp),%rax
mov    %dl,-0xf010(%rbp,%rax,1)
mov    -0x8(%rbp),%rax
mov    -0x11e54(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e54(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    149d <keypair+0x30d>
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x1000,-0x11e44(%rbp)
jge    155f <keypair+0x3cf>
mov    $0x0,%al
call   10b0 <rand@plt>
mov    $0x100,%ecx
cltd
idiv   %ecx
movslq -0x11e44(%rbp),%rax
mov    %dl,-0x10010(%rbp,%rax,1)
mov    -0x8(%rbp),%rax
mov    -0x11e54(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e54(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    1503 <keypair+0x373>
movl   $0x0,-0x11e5c(%rbp)
movl   $0x0,-0x11e60(%rbp)
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x8,-0x11e44(%rbp)
jge    179f <keypair+0x60f>
movl   $0x0,-0x11e48(%rbp)
cmpl   $0x200,-0x11e48(%rbp)
jge    15e1 <keypair+0x451>
mov    -0x11e44(%rbp),%eax
shl    $0x3,%eax
shl    $0x6,%eax
add    -0x11e48(%rbp),%eax
cltq
mov    -0x11010(%rbp,%rax,1),%cl
movslq -0x11e48(%rbp),%rax
mov    %cl,-0x11210(%rbp,%rax,1)
mov    -0x11e48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e48(%rbp)
jmp    1594 <keypair+0x404>
movl   $0x0,-0x11e48(%rbp)
cmpl   $0x8,-0x11e48(%rbp)
jge    1786 <keypair+0x5f6>
movl   $0x0,-0x11e4c(%rbp)
cmpl   $0x8,-0x11e4c(%rbp)
jge    1691 <keypair+0x501>
movl   $0x0,-0x11e50(%rbp)
cmpl   $0x40,-0x11e50(%rbp)
jge    1678 <keypair+0x4e8>
mov    -0x11e48(%rbp),%eax
shl    $0x6,%eax
mov    -0x11e4c(%rbp),%ecx
shl    $0x3,%ecx
shl    $0x6,%ecx
add    %ecx,%eax
add    -0x11e50(%rbp),%eax
cltq
mov    -0xf010(%rbp,%rax,1),%cl
mov    -0x11e4c(%rbp),%eax
shl    $0x6,%eax
add    -0x11e50(%rbp),%eax
cltq
mov    %cl,-0x11410(%rbp,%rax,1)
mov    -0x11e50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e50(%rbp)
jmp    1619 <keypair+0x489>
jmp    167d <keypair+0x4ed>
mov    -0x11e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e4c(%rbp)
jmp    1602 <keypair+0x472>
lea    -0x11210(%rbp),%rdi
lea    -0x11410(%rbp),%rsi
lea    -0x11e30(%rbp),%rdx
mov    $0x40,%ecx
mov    $0x8,%r8d
mov    $0x0,%al
call   1060 <tensorproduct@plt>
movl   $0x0,-0x11e4c(%rbp)
cmpl   $0x40,-0x11e4c(%rbp)
jge    1768 <keypair+0x5d8>
mov    -0x11e4c(%rbp),%eax
mov    %eax,-0x11e50(%rbp)
cmpl   $0x40,-0x11e50(%rbp)
jge    174f <keypair+0x5bf>
mov    -0x11e5c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x11e5c(%rbp)
cltq
mov    -0x11e30(%rbp,%rax,1),%dl
mov    -0x11e38(%rbp),%rax
mov    -0x11e60(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e60(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x11e54(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e54(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x11e50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e50(%rbp)
jmp    16db <keypair+0x54b>
jmp    1754 <keypair+0x5c4>
mov    -0x11e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e4c(%rbp)
jmp    16c2 <keypair+0x532>
movl   $0x0,-0x11e5c(%rbp)
mov    -0x11e48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e48(%rbp)
jmp    15eb <keypair+0x45b>
jmp    178b <keypair+0x5fb>
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    157d <keypair+0x3ed>
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x8,-0x11e44(%rbp)
jge    1a0d <keypair+0x87d>
movl   $0x0,-0x11e4c(%rbp)
cmpl   $0x8,-0x11e4c(%rbp)
jge    184f <keypair+0x6bf>
movl   $0x0,-0x11e50(%rbp)
cmpl   $0x40,-0x11e50(%rbp)
jge    1836 <keypair+0x6a6>
mov    -0x11e44(%rbp),%eax
shl    $0x3,%eax
shl    $0x6,%eax
mov    -0x11e4c(%rbp),%ecx
shl    $0x6,%ecx
add    %ecx,%eax
add    -0x11e50(%rbp),%eax
cltq
mov    -0x11010(%rbp,%rax,1),%cl
mov    -0x11e4c(%rbp),%eax
shl    $0x6,%eax
add    -0x11e50(%rbp),%eax
cltq
mov    %cl,-0x11210(%rbp,%rax,1)
mov    -0x11e50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e50(%rbp)
jmp    17d7 <keypair+0x647>
jmp    183b <keypair+0x6ab>
mov    -0x11e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e4c(%rbp)
jmp    17c0 <keypair+0x630>
movl   $0x0,-0x11e48(%rbp)
cmpl   $0x8,-0x11e48(%rbp)
jge    19f4 <keypair+0x864>
movl   $0x0,-0x11e4c(%rbp)
cmpl   $0x8,-0x11e4c(%rbp)
jge    18ff <keypair+0x76f>
movl   $0x0,-0x11e50(%rbp)
cmpl   $0x40,-0x11e50(%rbp)
jge    18e6 <keypair+0x756>
mov    -0x11e48(%rbp),%eax
shl    $0x6,%eax
mov    -0x11e4c(%rbp),%ecx
shl    $0x3,%ecx
shl    $0x6,%ecx
add    %ecx,%eax
add    -0x11e50(%rbp),%eax
cltq
mov    -0x10010(%rbp,%rax,1),%cl
mov    -0x11e4c(%rbp),%eax
shl    $0x6,%eax
add    -0x11e50(%rbp),%eax
cltq
mov    %cl,-0x11610(%rbp,%rax,1)
mov    -0x11e50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e50(%rbp)
jmp    1887 <keypair+0x6f7>
jmp    18eb <keypair+0x75b>
mov    -0x11e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e4c(%rbp)
jmp    1870 <keypair+0x6e0>
lea    -0x11210(%rbp),%rdi
lea    -0x11610(%rbp),%rsi
lea    -0x11e30(%rbp),%rdx
mov    $0x40,%ecx
mov    $0x8,%r8d
mov    $0x0,%al
call   1060 <tensorproduct@plt>
movl   $0x0,-0x11e4c(%rbp)
cmpl   $0x40,-0x11e4c(%rbp)
jge    19d6 <keypair+0x846>
mov    -0x11e4c(%rbp),%eax
mov    %eax,-0x11e50(%rbp)
cmpl   $0x40,-0x11e50(%rbp)
jge    19bd <keypair+0x82d>
mov    -0x11e5c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x11e5c(%rbp)
cltq
mov    -0x11e30(%rbp,%rax,1),%dl
mov    -0x11e38(%rbp),%rax
mov    -0x11e60(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e60(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x11e54(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e54(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x11e50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e50(%rbp)
jmp    1949 <keypair+0x7b9>
jmp    19c2 <keypair+0x832>
mov    -0x11e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e4c(%rbp)
jmp    1930 <keypair+0x7a0>
movl   $0x0,-0x11e5c(%rbp)
mov    -0x11e48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e48(%rbp)
jmp    1859 <keypair+0x6c9>
jmp    19f9 <keypair+0x869>
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    17a9 <keypair+0x619>
lea    -0x1010(%rbp),%rdi
lea    -0x3010(%rbp),%rdx
mov    $0x40,%esi
mov    $0x0,%al
call   1070 <matrixtranspose@plt>
movl   $0x0,-0x11e5c(%rbp)
movl   $0x0,-0x11e60(%rbp)
movl   $0x0,-0x11e68(%rbp)
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x80,-0x11e44(%rbp)
jge    1cad <keypair+0xb1d>
movl   $0x0,-0x11e4c(%rbp)
cmpl   $0x1000,-0x11e4c(%rbp)
jge    1a9c <keypair+0x90c>
movslq -0x11e4c(%rbp),%rax
movb   $0x0,-0x4010(%rbp,%rax,1)
mov    -0x11e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e4c(%rbp)
jmp    1a69 <keypair+0x8d9>
movl   $0x0,-0x11e4c(%rbp)
cmpl   $0x40,-0x11e4c(%rbp)
jge    1b2f <keypair+0x99f>
mov    -0x11e4c(%rbp),%eax
mov    %eax,-0x11e50(%rbp)
cmpl   $0x40,-0x11e50(%rbp)
jge    1b16 <keypair+0x986>
mov    -0x11e38(%rbp),%rax
mov    -0x11e5c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x11e5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x11e4c(%rbp),%eax
shl    $0x6,%eax
add    -0x11e50(%rbp),%eax
cltq
mov    %cl,-0x4010(%rbp,%rax,1)
mov    -0x11e50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e50(%rbp)
jmp    1abf <keypair+0x92f>
jmp    1b1b <keypair+0x98b>
mov    -0x11e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e4c(%rbp)
jmp    1aa6 <keypair+0x916>
lea    -0x3010(%rbp),%rdi
lea    -0x4010(%rbp),%rsi
lea    -0x5010(%rbp),%r9
mov    $0x40,%r8d
mov    %r8d,%edx
mov    %r8d,%ecx
mov    $0x0,%al
call   10a0 <matrixmul@plt>
lea    -0x5010(%rbp),%rdi
lea    -0x1010(%rbp),%rsi
lea    -0x6010(%rbp),%r9
mov    $0x40,%r8d
mov    %r8d,%edx
mov    %r8d,%ecx
mov    $0x0,%al
call   10a0 <matrixmul@plt>
movl   $0x0,-0x11e4c(%rbp)
cmpl   $0x40,-0x11e4c(%rbp)
jge    1c94 <keypair+0xb04>
mov    -0x11e4c(%rbp),%eax
mov    %eax,-0x11e50(%rbp)
cmpl   $0x40,-0x11e50(%rbp)
jge    1c7b <keypair+0xaeb>
mov    -0x11e50(%rbp),%eax
cmp    -0x11e4c(%rbp),%eax
jne    1bf7 <keypair+0xa67>
mov    -0x11e4c(%rbp),%eax
shl    $0x6,%eax
add    -0x11e50(%rbp),%eax
cltq
mov    -0x6010(%rbp,%rax,1),%dl
mov    -0x11e40(%rbp),%rax
mov    -0x11e60(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e60(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x11e50(%rbp),%eax
cmp    -0x11e4c(%rbp),%eax
je     1c62 <keypair+0xad2>
mov    -0x11e4c(%rbp),%eax
shl    $0x6,%eax
add    -0x11e50(%rbp),%eax
cltq
movzbl -0x6010(%rbp,%rax,1),%edi
ff
mov    -0x11e50(%rbp),%eax
shl    $0x6,%eax
add    -0x11e4c(%rbp),%eax
cltq
movzbl -0x6010(%rbp,%rax,1),%esi
ff
mov    $0x0,%al
call   1040 <add@plt>
mov    %al,%dl
mov    -0x11e40(%rbp),%rax
mov    -0x11e60(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e60(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1c67 <keypair+0xad7>
mov    -0x11e50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e50(%rbp)
jmp    1ba2 <keypair+0xa12>
jmp    1c80 <keypair+0xaf0>
mov    -0x11e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e4c(%rbp)
jmp    1b89 <keypair+0x9f9>
jmp    1c99 <keypair+0xb09>
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    1a4f <keypair+0x8bf>
lea    -0xa010(%rbp),%rdi
mov    -0x11e40(%rbp),%rsi
mov    -0x10(%rbp),%r9
mov    $0x80,%ecx
mov    $0x820,%r8d
mov    %ecx,%edx
mov    $0x0,%al
call   10a0 <matrixmul@plt>
movl   $0x0,-0x11e44(%rbp)
cmpl   $0x40,-0x11e44(%rbp)
jge    1d61 <keypair+0xbd1>
movl   $0x0,-0x11e48(%rbp)
cmpl   $0x40,-0x11e48(%rbp)
jge    1d48 <keypair+0xbb8>
mov    -0x11e44(%rbp),%eax
shl    $0x6,%eax
add    -0x11e48(%rbp),%eax
cltq
mov    -0x2010(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x11e54(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x11e54(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x11e48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e48(%rbp)
jmp    1cf4 <keypair+0xb64>
jmp    1d4d <keypair+0xbbd>
mov    -0x11e44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11e44(%rbp)
jmp    1cdd <keypair+0xb4d>
mov    -0x11e38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x11e40(%rbp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x11e70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<keypair>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x11e88,%rsp
mov    %rsi,0x50(%rsp)
mov    %rdi,0x28(%rsp)
mov    $0x41000,%edi
call   10a0 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    $0x41000,%edi
call   10a0 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %rax,0x38(%rsp)
lea    0xe4a(%rip),%rbp
mov    %rbp,%rdi
call   1050 <puts@plt>
lea    0xe1c(%rip),%rdi
call   1050 <puts@plt>
mov    %rbp,%rdi
call   1050 <puts@plt>
lea    0x5e80(%rsp),%r14
xor    %r15d,%r15d
nopl   0x0(%rax)
mov    %r15,%rax
shl    $0x6,%rax
lea    (%rsp,%rax,1),%r12
add    $0x5e80,%r12
lea    (%rsp,%rax,1),%rbx
add    $0x6e80,%rbx
xor    %ebp,%ebp
nop
xor    %eax,%eax
call   10d0 <rand@plt>
mov    %al,(%rbx,%rbp,1)
mov    %al,(%r12,%rbp,1)
add    $0x1,%rbp
cmp    $0x40,%rbp
jne    1240 <keypair+0x90>
add    $0x1,%r15
cmp    $0x40,%r15
jne    1220 <keypair+0x70>
mov    %r14,%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   10b0 <matrixinv@plt>
mov    $0x0,%r15d
test   %eax,%eax
je     1220 <keypair+0x70>
lea    0x9e80(%rsp),%r14
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rax
shl    $0x7,%rax
lea    (%rsp,%rax,1),%r12
add    $0x9e80,%r12
lea    (%rsp,%rax,1),%rbx
add    $0xde80,%rbx
xor    %ebp,%ebp
nop
xor    %eax,%eax
call   10d0 <rand@plt>
mov    %al,(%rbx,%rbp,1)
mov    %al,(%r12,%rbp,1)
add    $0x1,%rbp
cmp    $0x80,%rbp
jne    12b0 <keypair+0x100>
add    $0x1,%r15
cmp    $0x80,%r15
jne    1290 <keypair+0xe0>
mov    %r14,%rdi
mov    $0x80,%esi
xor    %eax,%eax
call   10b0 <matrixinv@plt>
mov    $0x0,%r15d
test   %eax,%eax
je     1290 <keypair+0xe0>
lea    0x9e80(%rsp),%rsi
mov    $0x4000,%edx
mov    0x28(%rsp),%rbp
mov    %rbp,%rdi
call   1070 <memcpy@plt>
xor    %ebx,%ebx
nopl   (%rax)
xor    %eax,%eax
call   10d0 <rand@plt>
mov    %al,0x3e80(%rsp,%rbx,1)
add    $0x1,%rbx
cmp    $0x1000,%rbx
jne    1310 <keypair+0x160>
xor    %ebx,%ebx
nopl   (%rax)
xor    %eax,%eax
call   10d0 <rand@plt>
mov    %al,0x1460(%rsp,%rbx,1)
mov    %al,0x4000(%rbp,%rbx,1)
add    $0x1,%rbx
cmp    $0x1000,%rbx
jne    1330 <keypair+0x180>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %eax,%eax
call   10d0 <rand@plt>
mov    %al,0x460(%rsp,%rbx,1)
mov    %al,0x5000(%rbp,%rbx,1)
add    $0x1,%rbx
cmp    $0x1000,%rbx
jne    1360 <keypair+0x1b0>
mov    $0x6000,%eax
mov    %rax,0x10(%rsp)
xor    %eax,%eax
xor    %ebp,%ebp
jmp    13b3 <keypair+0x203>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
add    $0x1,%rax
cmp    $0x8,%rax
je     17bb <keypair+0x60b>
mov    %rax,0x18(%rsp)
shl    $0x9,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x3e80,%rsi
mov    $0x200,%edx
lea    0x2460(%rsp),%rdi
call   1070 <memcpy@plt>
xor    %eax,%eax
jmp    13ef <keypair+0x23f>
nopl   (%rax)
mov    0x20(%rsp),%rax
add    $0x1,%rax
cmp    $0x8,%rax
je     13a0 <keypair+0x1f0>
mov    %rax,0x20(%rsp)
shl    $0x6,%rax
movaps 0x1460(%rsp,%rax,1),%xmm0
movaps 0x1470(%rsp,%rax,1),%xmm1
movaps 0x1480(%rsp,%rax,1),%xmm2
movaps 0x1490(%rsp,%rax,1),%xmm3
movaps %xmm3,0x290(%rsp)
movaps %xmm2,0x280(%rsp)
movaps %xmm1,0x270(%rsp)
movaps %xmm0,0x260(%rsp)
movaps 0x1690(%rsp,%rax,1),%xmm0
lea    0x2a0(%rsp),%rcx
movaps %xmm0,0x30(%rcx)
movaps 0x1680(%rsp,%rax,1),%xmm0
movaps %xmm0,0x20(%rcx)
movaps 0x1670(%rsp,%rax,1),%xmm0
movaps %xmm0,0x10(%rcx)
movaps 0x1660(%rsp,%rax,1),%xmm0
movaps %xmm0,(%rcx)
movaps 0x1860(%rsp,%rax,1),%xmm0
movaps 0x1870(%rsp,%rax,1),%xmm1
movaps 0x1880(%rsp,%rax,1),%xmm2
movaps 0x1890(%rsp,%rax,1),%xmm3
movaps %xmm3,0x70(%rcx)
movaps %xmm2,0x60(%rcx)
movaps %xmm1,0x50(%rcx)
movaps %xmm0,0x40(%rcx)
movaps 0x1a60(%rsp,%rax,1),%xmm0
movaps 0x1a70(%rsp,%rax,1),%xmm1
movaps 0x1a80(%rsp,%rax,1),%xmm2
movaps 0x1a90(%rsp,%rax,1),%xmm3
movaps %xmm3,0xb0(%rcx)
movaps %xmm2,0xa0(%rcx)
movaps %xmm1,0x90(%rcx)
movaps %xmm0,0x80(%rcx)
movaps 0x1c60(%rsp,%rax,1),%xmm0
movaps 0x1c70(%rsp,%rax,1),%xmm1
movaps 0x1c80(%rsp,%rax,1),%xmm2
movaps 0x1c90(%rsp,%rax,1),%xmm3
movaps %xmm0,0xc0(%rcx)
movaps %xmm1,0xd0(%rcx)
movaps %xmm2,0xe0(%rcx)
movaps %xmm3,0xf0(%rcx)
movaps 0x1e60(%rsp,%rax,1),%xmm0
movaps 0x1e70(%rsp,%rax,1),%xmm1
movaps 0x1e80(%rsp,%rax,1),%xmm2
movaps 0x1e90(%rsp,%rax,1),%xmm3
movaps %xmm3,0x130(%rcx)
movaps %xmm2,0x120(%rcx)
movaps %xmm1,0x110(%rcx)
movaps %xmm0,0x100(%rcx)
movaps 0x2060(%rsp,%rax,1),%xmm0
movaps 0x2070(%rsp,%rax,1),%xmm1
movaps 0x2080(%rsp,%rax,1),%xmm2
movaps 0x2090(%rsp,%rax,1),%xmm3
movaps %xmm3,0x170(%rcx)
movaps %xmm2,0x160(%rcx)
movaps %xmm1,0x150(%rcx)
movaps %xmm0,0x140(%rcx)
movdqa 0x2260(%rsp,%rax,1),%xmm0
movdqa 0x2270(%rsp,%rax,1),%xmm1
movdqa 0x2280(%rsp,%rax,1),%xmm2
movdqa 0x2290(%rsp,%rax,1),%xmm3
movdqa %xmm3,0x1b0(%rcx)
movdqa %xmm2,0x1a0(%rcx)
movdqa %xmm1,0x190(%rcx)
movdqa %xmm0,0x180(%rcx)
lea    0x2460(%rsp),%rdi
lea    0x260(%rsp),%rsi
lea    0x2660(%rsp),%rdx
mov    $0x40,%ecx
mov    $0x8,%r8d
xor    %eax,%eax
call   1080 <tensorproduct@plt>
mov    $0x3c,%esi
xor    %ebx,%ebx
xor    %r14d,%r14d
jmp    1626 <keypair+0x476>
nopl   0x0(%rax)
mov    %rdx,0x10(%rsp)
add    $0x1,%rbx
add    $0xffffffff,%esi
cmp    $0x40,%rbx
je     13e0 <keypair+0x230>
mov    %esi,(%rsp)
mov    $0x40,%r15d
sub    %ebx,%r15d
mov    $0x40,%r13d
sub    %rbx,%r13
movslq %ebp,%rbp
mov    %rbp,0x8(%rsp)
mov    0x30(%rsp),%rax
lea    (%rax,%rbp,1),%rdi
movslq %r14d,%r14
lea    (%rsp,%r14,1),%r12
add    $0x2660,%r12
mov    %r12,%rsi
mov    %r13,%rdx
call   1070 <memcpy@plt>
mov    0x10(%rsp),%rbp
movslq %ebp,%rbp
mov    0x28(%rsp),%rax
lea    (%rax,%rbp,1),%rdi
mov    %r12,%rsi
mov    %r13,%rdx
call   1070 <memcpy@plt>
cmp    $0x4,%r15d
jae    16a0 <keypair+0x4f0>
mov    %ebx,%ecx
mov    %rbp,%rdx
mov    0x8(%rsp),%rbp
mov    (%rsp),%esi
jmp    1794 <keypair+0x5e4>
nopl   0x0(%rax)
mov    $0x3c,%ecx
sub    %ebx,%ecx
mov    %ecx,%eax
shr    $0x2,%eax
add    $0x1,%eax
movq   %rbp,%xmm0
movq   %r14,%xmm1
movq   0x8(%rsp),%xmm2
pxor   %xmm3,%xmm3
cmp    $0x4,%ecx
jae    16e0 <keypair+0x530>
pxor   %xmm4,%xmm4
pxor   %xmm5,%xmm5
mov    (%rsp),%esi
jmp    172d <keypair+0x57d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsp),%esi
mov    %esi,%ecx
shr    $0x2,%ecx
add    $0x1,%ecx
and    $0xfffffffe,%ecx
pxor   %xmm3,%xmm3
pxor   %xmm4,%xmm4
pxor   %xmm5,%xmm5
movdqa 0x8fe(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
paddq  %xmm6,%xmm1
paddq  %xmm6,%xmm4
paddq  %xmm6,%xmm2
paddq  %xmm6,%xmm5
paddq  %xmm6,%xmm0
paddq  %xmm6,%xmm3
add    $0xfffffffe,%ecx
jne    1710 <keypair+0x560>
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
test   $0x1,%al
je     1753 <keypair+0x5a3>
pcmpeqd %xmm6,%xmm6
psubq  %xmm6,%xmm1
psubq  %xmm6,%xmm4
psubq  %xmm6,%xmm2
psubq  %xmm6,%xmm5
psubq  %xmm6,%xmm0
psubq  %xmm6,%xmm3
paddq  %xmm3,%xmm0
paddq  %xmm4,%xmm1
paddq  %xmm5,%xmm2
pshufd $0xee,%xmm2,%xmm3
paddq  %xmm2,%xmm3
movq   %xmm3,%rbp
pshufd $0xee,%xmm1,%xmm2
paddq  %xmm1,%xmm2
movq   %xmm2,%r14
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rdx
cmp    %ecx,%r15d
je     1610 <keypair+0x460>
add    %ebx,%ecx
add    $0xffffffc0,%ecx
xor    %eax,%eax
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rax
cmp    %eax,%ecx
jne    17a0 <keypair+0x5f0>
sub    %rax,%rdx
mov    %rdx,0x10(%rsp)
sub    %rax,%r14
sub    %rax,%rbp
jmp    1615 <keypair+0x465>
xor    %eax,%eax
jmp    17d3 <keypair+0x623>
nop
mov    0x18(%rsp),%rax
add    $0x1,%rax
cmp    $0x8,%rax
je     1bdb <keypair+0xa2b>
mov    %rax,0x18(%rsp)
shl    $0x9,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x3e80,%rsi
mov    $0x200,%edx
lea    0x2460(%rsp),%rdi
call   1070 <memcpy@plt>
xor    %eax,%eax
jmp    1812 <keypair+0x662>
nopl   (%rax)
mov    %rsi,%rbp
mov    0x20(%rsp),%rax
add    $0x1,%rax
cmp    $0x8,%rax
je     17c0 <keypair+0x610>
mov    %rax,0x20(%rsp)
shl    $0x6,%rax
movaps 0x460(%rsp,%rax,1),%xmm0
movaps 0x470(%rsp,%rax,1),%xmm1
movaps 0x480(%rsp,%rax,1),%xmm2
movaps 0x490(%rsp,%rax,1),%xmm3
movaps %xmm3,0x90(%rsp)
movaps %xmm2,0x80(%rsp)
movaps %xmm1,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps 0x690(%rsp,%rax,1),%xmm0
lea    0xa0(%rsp),%rcx
movaps %xmm0,0x30(%rcx)
movaps 0x680(%rsp,%rax,1),%xmm0
movaps %xmm0,0x20(%rcx)
movaps 0x670(%rsp,%rax,1),%xmm0
movaps %xmm0,0x10(%rcx)
movaps 0x660(%rsp,%rax,1),%xmm0
movaps %xmm0,(%rcx)
movaps 0x860(%rsp,%rax,1),%xmm0
movaps 0x870(%rsp,%rax,1),%xmm1
movaps 0x880(%rsp,%rax,1),%xmm2
movaps 0x890(%rsp,%rax,1),%xmm3
movaps %xmm3,0x70(%rcx)
movaps %xmm2,0x60(%rcx)
movaps %xmm1,0x50(%rcx)
movaps %xmm0,0x40(%rcx)
movaps 0xa60(%rsp,%rax,1),%xmm0
movaps 0xa70(%rsp,%rax,1),%xmm1
movaps 0xa80(%rsp,%rax,1),%xmm2
movaps 0xa90(%rsp,%rax,1),%xmm3
movaps %xmm3,0xb0(%rcx)
movaps %xmm2,0xa0(%rcx)
movaps %xmm1,0x90(%rcx)
movaps %xmm0,0x80(%rcx)
movaps 0xc60(%rsp,%rax,1),%xmm0
movaps 0xc70(%rsp,%rax,1),%xmm1
movaps 0xc80(%rsp,%rax,1),%xmm2
movaps 0xc90(%rsp,%rax,1),%xmm3
movaps %xmm0,0xc0(%rcx)
movaps %xmm1,0xd0(%rcx)
movaps %xmm2,0xe0(%rcx)
movaps %xmm3,0xf0(%rcx)
movaps 0xe60(%rsp,%rax,1),%xmm0
movaps 0xe70(%rsp,%rax,1),%xmm1
movaps 0xe80(%rsp,%rax,1),%xmm2
movaps 0xe90(%rsp,%rax,1),%xmm3
movaps %xmm3,0x130(%rcx)
movaps %xmm2,0x120(%rcx)
movaps %xmm1,0x110(%rcx)
movaps %xmm0,0x100(%rcx)
movaps 0x1060(%rsp,%rax,1),%xmm0
movaps 0x1070(%rsp,%rax,1),%xmm1
movaps 0x1080(%rsp,%rax,1),%xmm2
movaps 0x1090(%rsp,%rax,1),%xmm3
movaps %xmm3,0x170(%rcx)
movaps %xmm2,0x160(%rcx)
movaps %xmm1,0x150(%rcx)
movaps %xmm0,0x140(%rcx)
movdqa 0x1260(%rsp,%rax,1),%xmm0
movdqa 0x1270(%rsp,%rax,1),%xmm1
movdqa 0x1280(%rsp,%rax,1),%xmm2
movdqa 0x1290(%rsp,%rax,1),%xmm3
movdqa %xmm3,0x1b0(%rcx)
movdqa %xmm2,0x1a0(%rcx)
movdqa %xmm1,0x190(%rcx)
movdqa %xmm0,0x180(%rcx)
lea    0x2460(%rsp),%rdi
lea    0x60(%rsp),%rsi
lea    0x2660(%rsp),%rdx
mov    $0x40,%ecx
mov    $0x8,%r8d
xor    %eax,%eax
call   1080 <tensorproduct@plt>
mov    $0x3c,%edi
xor    %ebx,%ebx
xor    %r14d,%r14d
mov    %rbp,%rsi
jmp    1a46 <keypair+0x896>
cs nopw 0x0(%rax,%rax,1)
mov    %r13,0x10(%rsp)
add    $0x1,%rbx
add    $0xffffffff,%edi
cmp    $0x40,%rbx
je     1800 <keypair+0x650>
mov    %edi,(%rsp)
mov    $0x40,%r12d
sub    %ebx,%r12d
mov    $0x40,%ebp
sub    %rbx,%rbp
movslq %esi,%rsi
mov    %rsi,0x8(%rsp)
mov    0x30(%rsp),%rax
lea    (%rax,%rsi,1),%rdi
movslq %r14d,%r14
lea    (%rsp,%r14,1),%r15
add    $0x2660,%r15
mov    %r15,%rsi
mov    %rbp,%rdx
call   1070 <memcpy@plt>
mov    0x10(%rsp),%r13
movslq %r13d,%r13
mov    0x28(%rsp),%rax
lea    (%rax,%r13,1),%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1070 <memcpy@plt>
cmp    $0x4,%r12d
jae    1ac0 <keypair+0x910>
mov    %ebx,%ecx
mov    0x8(%rsp),%rsi
mov    (%rsp),%edi
jmp    1bb4 <keypair+0xa04>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x3c,%ecx
sub    %ebx,%ecx
mov    %ecx,%eax
shr    $0x2,%eax
add    $0x1,%eax
movq   %r13,%xmm0
movq   %r14,%xmm1
movq   0x8(%rsp),%xmm2
pxor   %xmm3,%xmm3
cmp    $0x4,%ecx
jae    1b00 <keypair+0x950>
pxor   %xmm4,%xmm4
pxor   %xmm5,%xmm5
mov    (%rsp),%edi
jmp    1b4d <keypair+0x99d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsp),%edi
mov    %edi,%ecx
shr    $0x2,%ecx
add    $0x1,%ecx
and    $0xfffffffe,%ecx
pxor   %xmm3,%xmm3
pxor   %xmm4,%xmm4
pxor   %xmm5,%xmm5
movdqa 0x4de(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
paddq  %xmm6,%xmm1
paddq  %xmm6,%xmm4
paddq  %xmm6,%xmm2
paddq  %xmm6,%xmm5
paddq  %xmm6,%xmm0
paddq  %xmm6,%xmm3
add    $0xfffffffe,%ecx
jne    1b30 <keypair+0x980>
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
test   $0x1,%al
je     1b73 <keypair+0x9c3>
pcmpeqd %xmm6,%xmm6
psubq  %xmm6,%xmm1
psubq  %xmm6,%xmm4
psubq  %xmm6,%xmm2
psubq  %xmm6,%xmm5
psubq  %xmm6,%xmm0
psubq  %xmm6,%xmm3
paddq  %xmm3,%xmm0
paddq  %xmm4,%xmm1
paddq  %xmm5,%xmm2
pshufd $0xee,%xmm2,%xmm3
paddq  %xmm2,%xmm3
movq   %xmm3,%rsi
pshufd $0xee,%xmm1,%xmm2
paddq  %xmm1,%xmm2
movq   %xmm2,%r14
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%r13
cmp    %ecx,%r12d
je     1a30 <keypair+0x880>
add    %ebx,%ecx
add    $0xffffffc0,%ecx
xor    %eax,%eax
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rax
cmp    %eax,%ecx
jne    1bc0 <keypair+0xa10>
sub    %rax,%r13
mov    %r13,0x10(%rsp)
sub    %rax,%r14
sub    %rax,%rsi
jmp    1a35 <keypair+0x885>
lea    0x6e80(%rsp),%rdi
lea    0x7e80(%rsp),%rdx
mov    $0x40,%esi
xor    %eax,%eax
call   1090 <matrixtranspose@plt>
addq   $0x1,0x48(%rsp)
lea    0x4e80(%rsp),%r14
xor    %eax,%eax
xor    %r13d,%r13d
xor    %ebx,%ebx
jmp    1c3c <keypair+0xa8c>
xchg   %ax,%ax
movslq 0x18(%rsp),%rax
lea    (%rax,%r12,1),%r13
add    $0x1,%r13
mov    0x44(%rsp),%eax
add    $0x1,%eax
cmp    $0x80,%eax
lea    0x4e80(%rsp),%r14
mov    0x58(%rsp),%rbx
je     1ec0 <keypair+0xd10>
mov    %eax,0x44(%rsp)
mov    $0x1000,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x3e,%r15d
xor    %r12d,%r12d
jmp    1c72 <keypair+0xac2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0xffffffffffffffff,%r15
cmp    $0x40,%r12
je     1d80 <keypair+0xbd0>
mov    $0x40,%ebp
sub    %r12,%rbp
mov    %r12,%rax
shl    $0x6,%rax
add    %r12,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x4e80,%rdi
movslq %ebx,%rbx
mov    0x30(%rsp),%rax
lea    (%rax,%rbx,1),%rsi
mov    %rbp,%rdx
call   1070 <memcpy@plt>
cmp    $0x2,%rbp
jae    1cc0 <keypair+0xb10>
mov    %r12,%rax
jmp    1d54 <keypair+0xba4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15,%rcx
shr    %rcx
mov    $0x3e,%eax
sub    %r12,%rax
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
movq   %rbx,%xmm0
cmp    $0xe,%rax
jae    1cf0 <keypair+0xb40>
pcmpeqd %xmm1,%xmm1
jmp    1d1a <keypair+0xb6a>
nopl   0x0(%rax)
lea    0x1(%rcx),%rax
and    $0xfffffffffffffff8,%rax
pcmpeqd %xmm1,%xmm1
movdqa 0x30c(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
paddq  %xmm2,%xmm0
add    $0xfffffffffffffff8,%rax
jne    1d10 <keypair+0xb60>
mov    %rbp,%rax
and    $0xfffffffffffffffe,%rax
test   $0x7,%dl
je     1d3a <keypair+0xb8a>
add    $0x1,%cl
movzbl %cl,%ecx
and    $0x7,%ecx
nop
psubq  %xmm1,%xmm0
add    $0xffffffffffffffff,%rcx
jne    1d30 <keypair+0xb80>
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rbx
cmp    %rax,%rbp
je     1c60 <keypair+0xab0>
add    %r12,%rax
add    $0xffffffffffffffc0,%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rax
jne    1d60 <keypair+0xbb0>
sub    %rcx,%rbx
jmp    1c60 <keypair+0xab0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,0x58(%rsp)
lea    0x7e80(%rsp),%rdi
mov    %r14,%rsi
mov    $0x40,%edx
mov    $0x40,%ecx
mov    $0x40,%r8d
lea    0x8e80(%rsp),%rbx
mov    %rbx,%r9
xor    %eax,%eax
call   10c0 <matrixmul@plt>
mov    %rbx,%rdi
lea    0x6e80(%rsp),%rsi
mov    $0x40,%edx
mov    $0x40,%ecx
mov    $0x40,%r8d
lea    0x2e80(%rsp),%rbx
mov    %rbx,%r9
xor    %eax,%eax
call   10c0 <matrixmul@plt>
lea    0x2ec0(%rsp),%rax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
jmp    1e23 <keypair+0xc73>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addq   $0x41,0x8(%rsp)
add    $0x41,%rbx
mov    (%rsp),%r13
add    %r12,%r13
mov    0x20(%rsp),%rax
mov    %rax,%r14
cmp    $0x40,%rax
je     1c10 <keypair+0xa60>
mov    %r13,%rdx
movslq %edx,%r15
mov    %r14,%rbp
shl    $0x6,%rbp
add    %r14,%rbp
mov    0x2e80(%rsp,%rbp,1),%al
mov    0x38(%rsp),%rcx
mov    %al,(%rcx,%r15,1)
lea    0x1(%r15),%r13
lea    0x1(%r14),%rax
cmp    $0x40,%rax
je     1c1d <keypair+0xa6d>
mov    %rax,0x20(%rsp)
mov    %rdx,0x18(%rsp)
mov    %r13,(%rsp)
add    0x48(%rsp),%r15
xor    %r12d,%r12d
mov    0x8(%rsp),%r13
jmp    1eb0 <keypair+0xd00>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x1(%rbx,%r12,1),%edi
movzbl 0x0(%r13),%esi
xor    %eax,%eax
call   1040 <add@plt>
mov    %al,(%r15,%r12,1)
add    $0x40,%r13
lea    (%r14,%r12,1),%rax
add    $0x1,%rax
add    $0x1,%r12
cmp    $0x3f,%rax
je     1e00 <keypair+0xc50>
cmp    $0xffffffffffffffff,%r12
jne    1e80 <keypair+0xcd0>
movzbl 0x2e80(%rsp,%rbp,1),%eax
jmp    1e92 <keypair+0xce2>
xor    %ebx,%ebx
lea    0xde80(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    $0x80,%edx
mov    $0x80,%ecx
mov    $0x820,%r8d
mov    0x50(%rsp),%r9
xor    %eax,%eax
call   10c0 <matrixmul@plt>
lea    0x5ec0(%rsp),%rax
mov    0x10(%rsp),%rdi
lea    0x40(%rdi),%ecx
mov    0x28(%rsp),%rsi
lea    (%rdi,%rbx,1),%edx
movslq %edx,%rdx
movups -0x40(%rax,%rbx,1),%xmm0
movups -0x30(%rax,%rbx,1),%xmm1
movups -0x20(%rax,%rbx,1),%xmm2
movups -0x10(%rax,%rbx,1),%xmm3
movups %xmm3,0x30(%rsi,%rdx,1)
movups %xmm2,0x20(%rsi,%rdx,1)
movups %xmm1,0x10(%rsi,%rdx,1)
movups %xmm0,(%rsi,%rdx,1)
lea    (%rcx,%rbx,1),%edx
movslq %edx,%rdx
movdqu (%rax,%rbx,1),%xmm0
movdqu 0x10(%rax,%rbx,1),%xmm1
movdqu 0x20(%rax,%rbx,1),%xmm2
movdqu 0x30(%rax,%rbx,1),%xmm3
movdqu %xmm3,0x30(%rsi,%rdx,1)
movdqu %xmm2,0x20(%rsi,%rdx,1)
movdqu %xmm1,0x10(%rsi,%rdx,1)
movdqu %xmm0,(%rsi,%rdx,1)
sub    $0xffffffffffffff80,%rbx
cmp    $0x1000,%rbx
jne    1f00 <keypair+0xd50>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x11e88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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