void rsdecode(unsigned char code[255], unsigned char mesg[249], int *errcode) {
  extern unsigned char v2e[256];
  unsigned char syn[7], deter, z[4], e0, e1, e2, n0, n1, n2, w0, w1, w2, x0,
      x[3];
  int sols;
  unsigned char i, j;
  *errcode = 0;
  j = 254;
  for (i = 0; i < 249; i++)
    mesg[i] = code[j--];
  syndrome(code, syn);
  if (syn[0] == 0)
    return;
  errnum(syn, &deter, errcode);
  if (*errcode == 4)
    return;
  switch (*errcode) {
  case 1:
    x0 = gfmul(syn[2], gfinv(syn[1]));
    w0 = gfmul(gfexp(syn[1], 2), gfinv(syn[2]));
    if (v2e[x0] > 5)
      mesg[254 - v2e[x0]] = ((mesg[254 - v2e[x0]]) ^ (w0));
    return;
  case 2:
    z[0] = gfmul(((gfmul(syn[1], syn[3])) ^ (gfexp(syn[2], 2))), gfinv(deter));
    z[1] = gfmul(((gfmul(syn[2], syn[3])) ^ (gfmul(syn[1], syn[4]))),
                 gfinv(deter));
    z[2] = 1;
    z[3] = 0;
    polysolve(z, x, &sols);
    if (sols != 2) {
      *errcode = 4;
      return;
    }
    w0 = gfmul(z[0], syn[1]);
    w1 = ((gfmul(z[0], syn[2])) ^ (gfmul(z[1], syn[1])));
    n0 = 254 - v2e[gfinv(x[0])];
    n1 = 254 - v2e[gfinv(x[1])];
    e0 = gfmul(((w0) ^ (gfmul(w1, x[0]))), gfinv(z[1]));
    e1 = gfmul(((w0) ^ (gfmul(w1, x[1]))), gfinv(z[1]));
    if (n0 < 249)
      mesg[n0] = ((mesg[n0]) ^ (e0));
    if (n1 < 249)
      mesg[n1] = ((mesg[n1]) ^ (e1));
    return;
  case 3:
    z[3] = 1;
    z[2] = gfmul(syn[1], gfmul(syn[4], syn[6]));
    z[2] = ((z[2]) ^ (gfmul(syn[1], gfmul(syn[5], syn[5]))));
    z[2] = ((z[2]) ^ (gfmul(syn[5], gfmul(syn[3], syn[3]))));
    z[2] = ((z[2]) ^ (gfmul(syn[3], gfmul(syn[4], syn[4]))));
    z[2] = ((z[2]) ^ (gfmul(syn[2], gfmul(syn[5], syn[4]))));
    z[2] = ((z[2]) ^ (gfmul(syn[2], gfmul(syn[3], syn[6]))));
    z[2] = gfmul(z[2], gfinv(deter));
    z[1] = gfmul(syn[1], gfmul(syn[3], syn[6]));
    z[1] = ((z[1]) ^ (gfmul(syn[1], gfmul(syn[5], syn[4]))));
    z[1] = ((z[1]) ^ (gfmul(syn[4], gfmul(syn[3], syn[3]))));
    z[1] = ((z[1]) ^ (gfmul(syn[2], gfmul(syn[4], syn[4]))));
    z[1] = ((z[1]) ^ (gfmul(syn[2], gfmul(syn[3], syn[5]))));
    z[1] = ((z[1]) ^ (gfmul(syn[2], gfmul(syn[2], syn[6]))));
    z[1] = gfmul(z[1], gfinv(deter));
    z[0] = gfmul(syn[2], gfmul(syn[3], syn[4]));
    z[0] = ((z[0]) ^ (gfmul(syn[3], gfmul(syn[2], syn[4]))));
    z[0] = ((z[0]) ^ (gfmul(syn[3], gfmul(syn[5], syn[1]))));
    z[0] = ((z[0]) ^ (gfmul(syn[4], gfmul(syn[4], syn[1]))));
    z[0] = ((z[0]) ^ (gfmul(syn[3], gfmul(syn[3], syn[3]))));
    z[0] = ((z[0]) ^ (gfmul(syn[2], gfmul(syn[2], syn[5]))));
    z[0] = gfmul(z[0], gfinv(deter));
    polysolve(z, x, &sols);
    if (sols != 3) {
      *errcode = 4;
      return;
    }
    w0 = gfmul(z[0], syn[1]);
    w1 = ((gfmul(z[0], syn[2])) ^ (gfmul(z[1], syn[1])));
    w2 = ((gfmul(z[0], syn[3])) ^
          (((gfmul(z[1], syn[2])) ^ (gfmul(z[2], syn[1])))));
    n0 = 254 - v2e[gfinv(x[0])];
    n1 = 254 - v2e[gfinv(x[1])];
    n2 = 254 - v2e[gfinv(x[2])];
    e0 = ((w0) ^ (((gfmul(w1, x[0])) ^ (gfmul(w2, gfexp(x[0], 2))))));
    e0 = gfmul(e0, gfinv(((z[1]) ^ (gfexp(x[0], 2)))));
    e1 = ((w0) ^ (((gfmul(w1, x[1])) ^ (gfmul(w2, gfexp(x[1], 2))))));
    e1 = gfmul(e1, gfinv(((z[1]) ^ (gfexp(x[1], 2)))));
    e2 = ((w0) ^ (((gfmul(w1, x[2])) ^ (gfmul(w2, gfexp(x[2], 2))))));
    e2 = gfmul(e2, gfinv(((z[1]) ^ (gfexp(x[2], 2)))));
    if (n0 < 249)
      mesg[n0] = ((mesg[n0]) ^ (e0));
    if (n1 < 249)
      mesg[n1] = ((mesg[n1]) ^ (e1));
    if (n2 < 249)
      mesg[n2] = ((mesg[n2]) ^ (e2));
    return;
  default:
    *errcode = 4;
    return;
  }
}


x86 assembly (clang, -O0):
<rsdecode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movb   $0xfe,-0x3a(%rbp)
movb   $0x0,-0x39(%rbp)
movzbl -0x39(%rbp),%eax
cmp    $0xf9,%eax
jge    11c5 <rsdecode+0x65>
mov    -0x8(%rbp),%rax
mov    -0x3a(%rbp),%cl
mov    %cl,%dl
add    $0xff,%dl
mov    %dl,-0x3a(%rbp)
movzbl %cl,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movzbl -0x39(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x39(%rbp),%al
add    $0x1,%al
mov    %al,-0x39(%rbp)
jmp    1189 <rsdecode+0x29>
mov    -0x8(%rbp),%rdi
lea    -0x1f(%rbp),%rsi
mov    $0x0,%al
call   1050 <syndrome@plt>
movzbl -0x1f(%rbp),%eax
cmp    $0x0,%eax
jne    11e6 <rsdecode+0x86>
jmp    1d47 <rsdecode+0xbe7>
lea    -0x1f(%rbp),%rdi
mov    -0x18(%rbp),%rdx
lea    -0x20(%rbp),%rsi
mov    $0x0,%al
call   1030 <errnum@plt>
mov    -0x18(%rbp),%rax
cmpl   $0x4,(%rax)
jne    120b <rsdecode+0xab>
jmp    1d47 <rsdecode+0xbe7>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
sub    $0x1,%eax
je     1244 <rsdecode+0xe4>
jmp    1222 <rsdecode+0xc2>
mov    -0x40(%rbp),%eax
sub    $0x2,%eax
je     12fe <rsdecode+0x19e>
jmp    1233 <rsdecode+0xd3>
mov    -0x40(%rbp),%eax
sub    $0x3,%eax
je     1515 <rsdecode+0x3b5>
jmp    1d3d <rsdecode+0xbdd>
movzbl -0x1d(%rbp),%eax
mov    %eax,-0x48(%rbp)
movzbl -0x1e(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x48(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x2e(%rbp)
movzbl -0x1e(%rbp),%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1040 <gfexp@plt>
mov    %eax,-0x44(%rbp)
movzbl -0x1d(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x44(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x2b(%rbp)
movzbl -0x2e(%rbp),%eax
mov    %eax,%ecx
mov    0x2d41(%rip),%rax
movzbl (%rax,%rcx,1),%eax
cmp    $0x5,%eax
jle    12f9 <rsdecode+0x199>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
mov    %ecx,%edx
mov    0x2d23(%rip),%rcx
movzbl (%rcx,%rdx,1),%edx
mov    $0xfe,%ecx
sub    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
movzbl -0x2b(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
mov    %ecx,%esi
mov    0x2cf8(%rip),%rcx
movzbl (%rcx,%rsi,1),%esi
mov    $0xfe,%ecx
sub    %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1d47 <rsdecode+0xbe7>
movzbl -0x1e(%rbp),%edi
movzbl -0x1c(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x58(%rbp)
movzbl -0x1d(%rbp),%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1040 <gfexp@plt>
mov    %eax,%ecx
mov    -0x58(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x54(%rbp)
movzbl -0x20(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x54(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x24(%rbp)
movzbl -0x1d(%rbp),%edi
movzbl -0x1c(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x50(%rbp)
movzbl -0x1e(%rbp),%edi
movzbl -0x1b(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movzbl -0x20(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x4c(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x23(%rbp)
movb   $0x1,-0x22(%rbp)
movb   $0x0,-0x21(%rbp)
lea    -0x24(%rbp),%rdi
lea    -0x31(%rbp),%rsi
lea    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1060 <polysolve@plt>
cmpl   $0x2,-0x38(%rbp)
je     13bd <rsdecode+0x25d>
mov    -0x18(%rbp),%rax
movl   $0x4,(%rax)
jmp    1d47 <rsdecode+0xbe7>
movzbl -0x24(%rbp),%edi
movzbl -0x1e(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x2b(%rbp)
movzbl -0x24(%rbp),%edi
movzbl -0x1d(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x6c(%rbp)
movzbl -0x23(%rbp),%edi
movzbl -0x1e(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x6c(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x2c(%rbp)
movzbl -0x31(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
movslq %eax,%rcx
mov    0x2bd1(%rip),%rax
movzbl (%rax,%rcx,1),%ecx
mov    $0xfe,%eax
sub    %ecx,%eax
mov    %al,-0x28(%rbp)
movzbl -0x30(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
movslq %eax,%rcx
mov    0x2bae(%rip),%rax
movzbl (%rax,%rcx,1),%ecx
mov    $0xfe,%eax
sub    %ecx,%eax
mov    %al,-0x29(%rbp)
movzbl -0x2b(%rbp),%eax
mov    %eax,-0x68(%rbp)
movzbl -0x2c(%rbp),%edi
movzbl -0x31(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x68(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x64(%rbp)
movzbl -0x23(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x64(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x25(%rbp)
movzbl -0x2b(%rbp),%eax
mov    %eax,-0x60(%rbp)
movzbl -0x2c(%rbp),%edi
movzbl -0x30(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x60(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x5c(%rbp)
movzbl -0x23(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x5c(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x26(%rbp)
movzbl -0x28(%rbp),%eax
cmp    $0xf9,%eax
jge    14e2 <rsdecode+0x382>
mov    -0x10(%rbp),%rax
movzbl -0x28(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x25(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movzbl -0x28(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
movzbl -0x29(%rbp),%eax
cmp    $0xf9,%eax
jge    1510 <rsdecode+0x3b0>
mov    -0x10(%rbp),%rax
movzbl -0x29(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x26(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movzbl -0x29(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1d47 <rsdecode+0xbe7>
movb   $0x1,-0x21(%rbp)
movzbl -0x1e(%rbp),%eax
mov    %eax,-0xfc(%rbp)
movzbl -0x1b(%rbp),%edi
movzbl -0x19(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xfc(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x22(%rbp)
movzbl -0x22(%rbp),%eax
mov    %eax,-0xf4(%rbp)
movzbl -0x1e(%rbp),%eax
mov    %eax,-0xf8(%rbp)
movzbl -0x1a(%rbp),%edi
movzbl -0x1a(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xf8(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xf4(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x22(%rbp)
movzbl -0x22(%rbp),%eax
mov    %eax,-0xec(%rbp)
movzbl -0x1a(%rbp),%eax
mov    %eax,-0xf0(%rbp)
movzbl -0x1c(%rbp),%edi
movzbl -0x1c(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xf0(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xec(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x22(%rbp)
movzbl -0x22(%rbp),%eax
mov    %eax,-0xe4(%rbp)
movzbl -0x1c(%rbp),%eax
mov    %eax,-0xe8(%rbp)
movzbl -0x1b(%rbp),%edi
movzbl -0x1b(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xe8(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xe4(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x22(%rbp)
movzbl -0x22(%rbp),%eax
mov    %eax,-0xdc(%rbp)
movzbl -0x1d(%rbp),%eax
mov    %eax,-0xe0(%rbp)
movzbl -0x1a(%rbp),%edi
movzbl -0x1b(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xe0(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xdc(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x22(%rbp)
movzbl -0x22(%rbp),%eax
mov    %eax,-0xd4(%rbp)
movzbl -0x1d(%rbp),%eax
mov    %eax,-0xd8(%rbp)
movzbl -0x1c(%rbp),%edi
movzbl -0x19(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xd8(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xd4(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x22(%rbp)
movzbl -0x22(%rbp),%eax
mov    %eax,-0xd0(%rbp)
movzbl -0x20(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0xd0(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x22(%rbp)
movzbl -0x1e(%rbp),%eax
mov    %eax,-0xcc(%rbp)
movzbl -0x1c(%rbp),%edi
movzbl -0x19(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xcc(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x23(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0xc4(%rbp)
movzbl -0x1e(%rbp),%eax
mov    %eax,-0xc8(%rbp)
movzbl -0x1a(%rbp),%edi
movzbl -0x1b(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xc8(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xc4(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x23(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0xbc(%rbp)
movzbl -0x1b(%rbp),%eax
mov    %eax,-0xc0(%rbp)
movzbl -0x1c(%rbp),%edi
movzbl -0x1c(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xc0(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xbc(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x23(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0xb4(%rbp)
movzbl -0x1d(%rbp),%eax
mov    %eax,-0xb8(%rbp)
movzbl -0x1b(%rbp),%edi
movzbl -0x1b(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xb8(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xb4(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x23(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0xac(%rbp)
movzbl -0x1d(%rbp),%eax
mov    %eax,-0xb0(%rbp)
movzbl -0x1c(%rbp),%edi
movzbl -0x1a(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xb0(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xac(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x23(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0xa4(%rbp)
movzbl -0x1d(%rbp),%eax
mov    %eax,-0xa8(%rbp)
movzbl -0x1d(%rbp),%edi
movzbl -0x19(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0xa8(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x23(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0xa0(%rbp)
movzbl -0x20(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0xa0(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x23(%rbp)
movzbl -0x1d(%rbp),%eax
mov    %eax,-0x9c(%rbp)
movzbl -0x1c(%rbp),%edi
movzbl -0x1b(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x9c(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x24(%rbp)
movzbl -0x24(%rbp),%eax
mov    %eax,-0x94(%rbp)
movzbl -0x1c(%rbp),%eax
mov    %eax,-0x98(%rbp)
movzbl -0x1d(%rbp),%edi
movzbl -0x1b(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x98(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x24(%rbp)
movzbl -0x24(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movzbl -0x1c(%rbp),%eax
mov    %eax,-0x90(%rbp)
movzbl -0x1a(%rbp),%edi
movzbl -0x1e(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x90(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x8c(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x24(%rbp)
movzbl -0x24(%rbp),%eax
mov    %eax,-0x84(%rbp)
movzbl -0x1b(%rbp),%eax
mov    %eax,-0x88(%rbp)
movzbl -0x1b(%rbp),%edi
movzbl -0x1e(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x88(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x24(%rbp)
movzbl -0x24(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movzbl -0x1c(%rbp),%eax
mov    %eax,-0x80(%rbp)
movzbl -0x1c(%rbp),%edi
movzbl -0x1c(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x80(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x24(%rbp)
movzbl -0x24(%rbp),%eax
mov    %eax,-0x74(%rbp)
movzbl -0x1d(%rbp),%eax
mov    %eax,-0x78(%rbp)
movzbl -0x1d(%rbp),%edi
movzbl -0x1a(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x78(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x74(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x24(%rbp)
movzbl -0x24(%rbp),%eax
mov    %eax,-0x70(%rbp)
movzbl -0x20(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x70(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x24(%rbp)
lea    -0x24(%rbp),%rdi
lea    -0x31(%rbp),%rsi
lea    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1060 <polysolve@plt>
cmpl   $0x3,-0x38(%rbp)
je     19ce <rsdecode+0x86e>
mov    -0x18(%rbp),%rax
movl   $0x4,(%rax)
jmp    1d47 <rsdecode+0xbe7>
movzbl -0x24(%rbp),%edi
movzbl -0x1e(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x2b(%rbp)
movzbl -0x24(%rbp),%edi
movzbl -0x1d(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x144(%rbp)
movzbl -0x23(%rbp),%edi
movzbl -0x1e(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,%ecx
mov    -0x144(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x2c(%rbp)
movzbl -0x24(%rbp),%edi
movzbl -0x1c(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x13c(%rbp)
movzbl -0x23(%rbp),%edi
movzbl -0x1d(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x140(%rbp)
movzbl -0x22(%rbp),%edi
movzbl -0x1e(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x140(%rbp),%ecx
mov    %eax,%edx
mov    -0x13c(%rbp),%eax
xor    %edx,%ecx
xor    %ecx,%eax
mov    %al,-0x2d(%rbp)
movzbl -0x31(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
movslq %eax,%rcx
mov    0x256c(%rip),%rax
movzbl (%rax,%rcx,1),%ecx
mov    $0xfe,%eax
sub    %ecx,%eax
mov    %al,-0x28(%rbp)
movzbl -0x30(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
movslq %eax,%rcx
mov    0x2549(%rip),%rax
movzbl (%rax,%rcx,1),%ecx
mov    $0xfe,%eax
sub    %ecx,%eax
mov    %al,-0x29(%rbp)
movzbl -0x2f(%rbp),%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
movslq %eax,%rcx
mov    0x2526(%rip),%rax
movzbl (%rax,%rcx,1),%ecx
mov    $0xfe,%eax
sub    %ecx,%eax
mov    %al,-0x2a(%rbp)
movzbl -0x2b(%rbp),%eax
mov    %eax,-0x130(%rbp)
movzbl -0x2c(%rbp),%edi
movzbl -0x31(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x134(%rbp)
movzbl -0x2d(%rbp),%eax
mov    %eax,-0x138(%rbp)
movzbl -0x31(%rbp),%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1040 <gfexp@plt>
mov    -0x138(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x134(%rbp),%ecx
mov    %eax,%edx
mov    -0x130(%rbp),%eax
xor    %edx,%ecx
xor    %ecx,%eax
mov    %al,-0x25(%rbp)
movzbl -0x25(%rbp),%eax
mov    %eax,-0x128(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0x12c(%rbp)
movzbl -0x31(%rbp),%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1040 <gfexp@plt>
mov    -0x12c(%rbp),%edi
xor    %eax,%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x128(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x25(%rbp)
movzbl -0x2b(%rbp),%eax
mov    %eax,-0x11c(%rbp)
movzbl -0x2c(%rbp),%edi
movzbl -0x30(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x120(%rbp)
movzbl -0x2d(%rbp),%eax
mov    %eax,-0x124(%rbp)
movzbl -0x30(%rbp),%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1040 <gfexp@plt>
mov    -0x124(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x120(%rbp),%ecx
mov    %eax,%edx
mov    -0x11c(%rbp),%eax
xor    %edx,%ecx
xor    %ecx,%eax
mov    %al,-0x26(%rbp)
movzbl -0x26(%rbp),%eax
mov    %eax,-0x114(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0x118(%rbp)
movzbl -0x30(%rbp),%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1040 <gfexp@plt>
mov    -0x118(%rbp),%edi
xor    %eax,%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x114(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x26(%rbp)
movzbl -0x2b(%rbp),%eax
mov    %eax,-0x108(%rbp)
movzbl -0x2c(%rbp),%edi
movzbl -0x2f(%rbp),%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %eax,-0x10c(%rbp)
movzbl -0x2d(%rbp),%eax
mov    %eax,-0x110(%rbp)
movzbl -0x2f(%rbp),%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1040 <gfexp@plt>
mov    -0x110(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    -0x10c(%rbp),%ecx
mov    %eax,%edx
mov    -0x108(%rbp),%eax
xor    %edx,%ecx
xor    %ecx,%eax
mov    %al,-0x27(%rbp)
movzbl -0x27(%rbp),%eax
mov    %eax,-0x100(%rbp)
movzbl -0x23(%rbp),%eax
mov    %eax,-0x104(%rbp)
movzbl -0x2f(%rbp),%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1040 <gfexp@plt>
mov    -0x104(%rbp),%edi
xor    %eax,%edi
mov    $0x0,%al
call   1080 <gfinv@plt>
mov    -0x100(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   1070 <gfmul@plt>
mov    %al,-0x27(%rbp)
movzbl -0x28(%rbp),%eax
cmp    $0xf9,%eax
jge    1cdc <rsdecode+0xb7c>
mov    -0x10(%rbp),%rax
movzbl -0x28(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x25(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movzbl -0x28(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
movzbl -0x29(%rbp),%eax
cmp    $0xf9,%eax
jge    1d0a <rsdecode+0xbaa>
mov    -0x10(%rbp),%rax
movzbl -0x29(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x26(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movzbl -0x29(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
movzbl -0x2a(%rbp),%eax
cmp    $0xf9,%eax
jge    1d38 <rsdecode+0xbd8>
mov    -0x10(%rbp),%rax
movzbl -0x2a(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x27(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movzbl -0x2a(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1d47 <rsdecode+0xbe7>
mov    -0x18(%rbp),%rax
movl   $0x4,(%rax)
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rsdecode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,%r14
mov    %rsi,%rbx
movl   $0x0,(%rdx)
lea    0xf9(%rsi),%rax
lea    0x6(%rdi),%rdx
lea    0xff(%rdi),%rcx
cmp    %rsi,%rcx
jbe    11a2 <rsdecode+0x42>
cmp    %rax,%rdx
jae    11a2 <rsdecode+0x42>
xor    %ebp,%ebp
mov    $0xfe,%esi
jmp    1552 <rsdecode+0x3f2>
movdqu 0xdf(%rdi),%xmm1
movdqu 0xef(%rdi),%xmm2
pxor   %xmm0,%xmm0
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%rbx)
movdqu %xmm1,0x10(%rbx)
movdqu 0xbf(%rdi),%xmm1
movdqu 0xcf(%rdi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,0x20(%rbx)
movdqu %xmm1,0x30(%rbx)
movdqu 0x9f(%rdi),%xmm1
movdqu 0xaf(%rdi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,0x40(%rbx)
movdqu %xmm1,0x50(%rbx)
movdqu 0x7f(%rdi),%xmm1
movdqu 0x8f(%rdi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,0x60(%rbx)
movdqu %xmm1,0x70(%rbx)
movdqu 0x5f(%rdi),%xmm1
movdqu 0x6f(%rdi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,0x80(%rbx)
movdqu %xmm1,0x90(%rbx)
movdqu 0x3f(%rdi),%xmm1
movdqu 0x4f(%rdi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,0xa0(%rbx)
movdqu %xmm1,0xb0(%rbx)
movdqu 0x1f(%rdi),%xmm1
movdqu 0x2f(%rdi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,0xc0(%rbx)
movdqu %xmm1,0xd0(%rbx)
movq   0x17(%rdi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0xe0(%rbx)
movq   0xf(%rdi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0xe8(%rbx)
movq   0x7(%rdi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0xf0(%rbx)
mov    $0x6,%esi
mov    $0xf8,%ebp
cmp    %rax,%rdx
setb   %dl
cmp    %rbx,%rcx
seta   %al
and    %dl,%al
add    %rdi,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rsi,%rcx,1),%edx
mov    %dl,(%rbx,%rbp,1)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rcx
jb     1570 <rsdecode+0x410>
test   %al,%al
je     15bf <rsdecode+0x45f>
add    %rcx,%rsi
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%eax
mov    %al,(%rbx,%rbp,1)
movzbl -0x1(%rsi),%eax
mov    %al,0x1(%rbx,%rbp,1)
movzbl -0x2(%rsi),%eax
mov    %al,0x2(%rbx,%rbp,1)
movzbl -0x3(%rsi),%eax
mov    %al,0x3(%rbx,%rbp,1)
add    $0x4,%rbp
add    $0xfffffffffffffffc,%rsi
cmp    $0xf9,%rbp
jne    1590 <rsdecode+0x430>
lea    0x12(%rsp),%rsi
xor    %eax,%eax
call   1050 <syndrome@plt>
cmpb   $0x0,0x12(%rsp)
je     1dd1 <rsdecode+0xc71>
lea    0x12(%rsp),%rdi
lea    0x1c(%rsp),%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1030 <errnum@plt>
mov    (%r14),%eax
add    $0xffffffff,%eax
cmp    $0x3,%eax
ja     1dca <rsdecode+0xc6a>
lea    0xa00(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl 0x14(%rsp),%ebp
movzbl 0x13(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r14d
movzbl 0x13(%rsp),%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <gfexp@plt>
mov    %eax,%ebp
movzbl 0x14(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
movzbl %r14b,%ecx
mov    0x2983(%rip),%rdx
movzbl (%rdx,%rcx,1),%ecx
cmp    $0x6,%rcx
jb     1dd1 <rsdecode+0xc71>
sub    %rcx,%rbx
xor    %al,0xfe(%rbx)
jmp    1dd1 <rsdecode+0xc71>
movzbl 0x13(%rsp),%edi
movzbl 0x15(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
movzbl 0x14(%rsp),%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <gfexp@plt>
xor    %eax,%ebp
movzbl 0x1c(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %al,0xe(%rsp)
movzbl 0x14(%rsp),%edi
movzbl 0x15(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
movzbl 0x13(%rsp),%edi
movzbl 0x16(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %eax,%ebp
movzbl 0x1c(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %al,0xf(%rsp)
movw   $0x1,0x10(%rsp)
lea    0xe(%rsp),%rdi
lea    0x19(%rsp),%rsi
lea    0x20(%rsp),%rdx
xor    %eax,%eax
call   1060 <polysolve@plt>
cmpl   $0x2,0x20(%rsp)
jne    1dca <rsdecode+0xc6a>
movzbl 0xe(%rsp),%edi
movzbl 0x13(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r12d
movzbl 0xe(%rsp),%edi
movzbl 0x14(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r15d
movzbl 0xf(%rsp),%edi
movzbl 0x13(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
xor    %r15d,%ebp
movzbl 0x19(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
cltq
mov    0x286a(%rip),%r15
mov    $0xfe,%r13b
mov    $0xfe,%r14b
sub    (%r15,%rax,1),%r14b
movzbl 0x1a(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
cltq
sub    (%r15,%rax,1),%r13b
movzbl %r12b,%r15d
movzbl %bpl,%r12d
movzbl 0x19(%rsp),%esi
mov    %r12d,%edi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
xor    %r15d,%ebp
movzbl 0xf(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
movzbl 0x1a(%rsp),%esi
mov    %r12d,%edi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %eax,%r15d
movzbl 0xf(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
cmp    $0xf8,%r14b
ja     17ff <rsdecode+0x69f>
movzbl %r14b,%ecx
xor    %bpl,(%rbx,%rcx,1)
cmp    $0xf8,%r13b
ja     1dd1 <rsdecode+0xc71>
movzbl %r13b,%ecx
xor    %al,(%rbx,%rcx,1)
jmp    1dd1 <rsdecode+0xc71>
movb   $0x1,0x11(%rsp)
movzbl 0x13(%rsp),%ebp
movzbl 0x16(%rsp),%edi
movzbl 0x18(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r12d
mov    %r12b,0x10(%rsp)
movzbl 0x13(%rsp),%r15d
movzbl 0x17(%rsp),%edi
mov    %edi,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
xor    %r12d,%ebp
mov    %bpl,0x10(%rsp)
movzbl 0x17(%rsp),%r15d
movzbl 0x15(%rsp),%edi
mov    %edi,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r15d
xor    %ebp,%r15d
mov    %r15b,0x10(%rsp)
movzbl 0x15(%rsp),%ebp
movzbl 0x16(%rsp),%edi
mov    %edi,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
xor    %r15d,%ebp
mov    %bpl,0x10(%rsp)
movzbl 0x14(%rsp),%r15d
movzbl 0x17(%rsp),%edi
movzbl 0x16(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r15d
xor    %ebp,%r15d
mov    %r15b,0x10(%rsp)
movzbl 0x14(%rsp),%ebp
movzbl 0x15(%rsp),%edi
movzbl 0x18(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %r15d,%eax
mov    %al,0x10(%rsp)
movzbl %al,%ebp
movzbl 0x1c(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %al,0x10(%rsp)
movzbl 0x13(%rsp),%ebp
movzbl 0x15(%rsp),%edi
movzbl 0x18(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r12d
mov    %r12b,0xf(%rsp)
movzbl 0x13(%rsp),%r15d
movzbl 0x17(%rsp),%edi
movzbl 0x16(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
xor    %r12d,%ebp
mov    %bpl,0xf(%rsp)
movzbl 0x16(%rsp),%r15d
movzbl 0x15(%rsp),%edi
mov    %edi,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r15d
xor    %ebp,%r15d
mov    %r15b,0xf(%rsp)
movzbl 0x14(%rsp),%ebp
movzbl 0x16(%rsp),%edi
mov    %edi,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r12d
xor    %r15d,%r12d
mov    %r12b,0xf(%rsp)
movzbl 0x14(%rsp),%r15d
movzbl 0x15(%rsp),%edi
movzbl 0x17(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
xor    %r12d,%ebp
mov    %bpl,0xf(%rsp)
movzbl 0x14(%rsp),%r15d
movzbl 0x18(%rsp),%esi
mov    %r15d,%edi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %ebp,%eax
mov    %al,0xf(%rsp)
movzbl %al,%ebp
movzbl 0x1c(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %al,0xf(%rsp)
movzbl 0x14(%rsp),%ebp
movzbl 0x15(%rsp),%edi
movzbl 0x16(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r12d
mov    %r12b,0xe(%rsp)
movzbl 0x15(%rsp),%r15d
movzbl 0x14(%rsp),%edi
movzbl 0x16(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r13d
xor    %r12d,%r13d
mov    %r13b,0xe(%rsp)
movzbl 0x15(%rsp),%r15d
movzbl 0x17(%rsp),%edi
movzbl 0x13(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r12d
xor    %r13d,%r12d
mov    %r12b,0xe(%rsp)
movzbl 0x16(%rsp),%r15d
movzbl 0x13(%rsp),%esi
mov    %r15d,%edi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r15d
xor    %r12d,%r15d
mov    %r15b,0xe(%rsp)
movzbl 0x15(%rsp),%ebp
mov    %ebp,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
xor    %r15d,%ebp
mov    %bpl,0xe(%rsp)
movzbl 0x14(%rsp),%r15d
movzbl 0x17(%rsp),%esi
mov    %r15d,%edi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %r15d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %ebp,%eax
mov    %al,0xe(%rsp)
movzbl %al,%ebp
movzbl 0x1c(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %ebp,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %al,0xe(%rsp)
lea    0xe(%rsp),%rdi
lea    0x19(%rsp),%rsi
lea    0x20(%rsp),%rdx
xor    %eax,%eax
call   1060 <polysolve@plt>
cmpl   $0x3,0x20(%rsp)
jne    1dca <rsdecode+0xc6a>
movzbl 0xe(%rsp),%edi
movzbl 0x13(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r14d
movzbl 0xe(%rsp),%edi
movzbl 0x14(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
movzbl 0xf(%rsp),%edi
movzbl 0x13(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r15d
xor    %ebp,%r15d
movzbl 0xe(%rsp),%edi
movzbl 0x15(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r12d
movzbl 0xf(%rsp),%edi
movzbl 0x14(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r13d
movzbl 0x10(%rsp),%edi
movzbl 0x13(%rsp),%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %r12d,%r13d
xor    %eax,%r13d
movzbl 0x19(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
cltq
mov    0x23c2(%rip),%rbp
mov    $0xfe,%r12b
mov    $0xfe,%cl
sub    0x0(%rbp,%rax,1),%cl
mov    %cl,0x1d(%rsp)
movzbl 0x1a(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
cltq
mov    $0xfe,%cl
sub    0x0(%rbp,%rax,1),%cl
mov    %cl,0x1e(%rsp)
movzbl 0x1b(%rsp),%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
cltq
sub    0x0(%rbp,%rax,1),%r12b
mov    %r12b,0x1f(%rsp)
movzbl %r15b,%r15d
movzbl 0x19(%rsp),%esi
mov    %r15d,%edi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
movzbl %r13b,%r12d
movzbl 0x19(%rsp),%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <gfexp@plt>
mov    %r12d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %r14d,%ebp
xor    %eax,%ebp
movzbl %bpl,%r13d
movzbl 0xf(%rsp),%ebp
movzbl 0x19(%rsp),%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <gfexp@plt>
xor    %eax,%ebp
mov    %ebp,%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %r13d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,0x24(%rsp)
movzbl 0x1a(%rsp),%esi
mov    %r15d,%edi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
movzbl 0x1a(%rsp),%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <gfexp@plt>
mov    %r12d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %r14d,%ebp
xor    %eax,%ebp
movzbl %bpl,%r13d
movzbl 0xf(%rsp),%ebp
movzbl 0x1a(%rsp),%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <gfexp@plt>
xor    %eax,%ebp
mov    %ebp,%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %r13d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%r13d
movzbl 0x1b(%rsp),%esi
mov    %r15d,%edi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    %eax,%ebp
movzbl 0x1b(%rsp),%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <gfexp@plt>
mov    %r12d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
xor    %r14d,%ebp
xor    %eax,%ebp
movzbl %bpl,%r14d
movzbl 0xf(%rsp),%ebp
movzbl 0x1b(%rsp),%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <gfexp@plt>
xor    %eax,%ebp
mov    %ebp,%edi
xor    %eax,%eax
call   1080 <gfinv@plt>
mov    %r14d,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <gfmul@plt>
mov    0x1d(%rsp),%cl
cmp    $0xf8,%cl
ja     1da9 <rsdecode+0xc49>
movzbl %cl,%ecx
mov    0x24(%rsp),%edx
xor    %dl,(%rbx,%rcx,1)
mov    0x1e(%rsp),%cl
cmp    $0xf8,%cl
ja     1db9 <rsdecode+0xc59>
movzbl %cl,%ecx
xor    %r13b,(%rbx,%rcx,1)
mov    0x1f(%rsp),%cl
cmp    $0xf8,%cl
ja     1dd1 <rsdecode+0xc71>
movzbl %cl,%ecx
xor    %al,(%rbx,%rcx,1)
jmp    1dd1 <rsdecode+0xc71>
movl   $0x4,(%r14)
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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