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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ E;

/* Variables and functions */
int /*<<< orphan*/ memmove(unsigned char *, unsigned char *, unsigned int);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ redupe_find_errata_locator(unsigned char *, unsigned int,
                                              unsigned char *, unsigned int *);
int /*<<< orphan*/ redupe_find_error_evaluator(unsigned char *, unsigned int,
                                               unsigned char *, unsigned int,
                                               unsigned int, unsigned char *,
                                               unsigned int *);
unsigned char redupe_gf_div(unsigned char, unsigned char);
unsigned char redupe_gf_inv(unsigned char);
unsigned char redupe_gf_mul(unsigned char, unsigned char);
int /*<<< orphan*/ redupe_gf_poly_add(unsigned char *, unsigned int,
                                      unsigned char *, unsigned int,
                                      unsigned char *, unsigned int *);
unsigned char redupe_gf_poly_eval(unsigned char *, unsigned int, unsigned char);
unsigned char redupe_gf_pow(unsigned char, int);
unsigned char redupe_gf_sub(int, unsigned char);
void redupe_correct_errata(unsigned char *msg, unsigned msg_sz,
                           const unsigned char *synd, unsigned synd_sz,
                           const unsigned char *err_pos, unsigned err_pos_sz) {
  unsigned char coef_pos[256];
  unsigned coef_pos_sz = err_pos_sz;
  for (unsigned i = 0; i < coef_pos_sz; ++i) {
    coef_pos[i] = msg_sz - 1 - err_pos[i];
  }
  unsigned char err_loc[256];
  unsigned err_loc_sz = 0;
  redupe_find_errata_locator(coef_pos, coef_pos_sz, err_loc, &err_loc_sz);
  unsigned char tmp[256];
  unsigned tmp_sz = synd_sz;
  for (unsigned i = 0; i < synd_sz; ++i) {
    tmp[synd_sz - i - 1] = synd[i];
  }
  unsigned char err_eval[256];
  unsigned err_eval_sz = 0;
  redupe_find_error_evaluator(tmp, tmp_sz, err_loc, err_loc_sz, err_loc_sz - 1,
                              err_eval, &err_eval_sz);
  for (unsigned i = 0; i < err_eval_sz / 2; ++i) {
    unsigned char t = err_eval[i];
    err_eval[i] = err_eval[err_eval_sz - i - 1];
    err_eval[err_eval_sz - i - 1] = t;
  }
  unsigned char X[256];
  unsigned X_sz = coef_pos_sz;
  for (unsigned i = 0; i < coef_pos_sz; ++i) {
    int l = 255 - coef_pos[i];
    X[i] = redupe_gf_pow(2, -l);
  }
  unsigned char E[256];
  unsigned E_sz = msg_sz;
  memset(E, 0, sizeof(E));
  for (unsigned i = 0; i < X_sz; ++i) {
    unsigned char xinv = redupe_gf_inv(X[i]);
    unsigned char err_loc_prime = 1;
    for (unsigned j = 0; j < X_sz; ++j) {
      if (j == i) {
        continue;
      }
      unsigned char t = redupe_gf_mul(xinv, X[j]);
      t = redupe_gf_sub(1, t);
      err_loc_prime = redupe_gf_mul(err_loc_prime, t);
    }
    tmp_sz = err_eval_sz;
    for (unsigned j = 0; j < err_eval_sz; ++j) {
      tmp[tmp_sz - j - 1] = err_eval[j];
    }
    unsigned char y = redupe_gf_poly_eval(tmp, tmp_sz, xinv);
    y = redupe_gf_mul(redupe_gf_pow(X[i], 1), y);
    E[err_pos[i]] = redupe_gf_div(y, err_loc_prime);
  }
  tmp_sz = msg_sz;
  memmove(tmp, msg, msg_sz);
  redupe_gf_poly_add(tmp, tmp_sz, E, E_sz, msg, &tmp_sz);
}


x86 assembly (clang, -O0):
<redupe_correct_errata>:
push   %rbp
mov    %rsp,%rbp
sub    $0x6b0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x134(%rbp)
movl   $0x0,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    -0x134(%rbp),%eax
jae    122f <redupe_correct_errata+0x7f>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    -0x28(%rbp),%rcx
mov    -0x138(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%cl
mov    -0x138(%rbp),%eax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    11e4 <redupe_correct_errata+0x34>
movl   $0x0,-0x244(%rbp)
lea    -0x130(%rbp),%rdi
mov    -0x134(%rbp),%esi
lea    -0x240(%rbp),%rdx
lea    -0x244(%rbp),%rcx
call   10c0 <redupe_find_errata_locator@plt>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x354(%rbp)
movl   $0x0,-0x358(%rbp)
mov    -0x358(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    12b1 <redupe_correct_errata+0x101>
mov    -0x18(%rbp),%rax
mov    -0x358(%rbp),%ecx
mov    (%rax,%rcx,1),%cl
mov    -0x1c(%rbp),%eax
sub    -0x358(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    %cl,-0x350(%rbp,%rax,1)
mov    -0x358(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x358(%rbp)
jmp    126c <redupe_correct_errata+0xbc>
movl   $0x0,-0x464(%rbp)
lea    -0x350(%rbp),%rdi
mov    -0x354(%rbp),%esi
lea    -0x240(%rbp),%rdx
mov    -0x244(%rbp),%ecx
mov    -0x244(%rbp),%r8d
sub    $0x1,%r8d
lea    -0x460(%rbp),%r9
lea    -0x464(%rbp),%rax
mov    %rax,(%rsp)
call   10b0 <redupe_find_error_evaluator@plt>
movl   $0x0,-0x468(%rbp)
mov    -0x468(%rbp),%eax
mov    -0x464(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
jae    1382 <redupe_correct_errata+0x1d2>
mov    -0x468(%rbp),%eax
mov    -0x460(%rbp,%rax,1),%al
mov    %al,-0x469(%rbp)
mov    -0x464(%rbp),%eax
sub    -0x468(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    -0x460(%rbp,%rax,1),%cl
mov    -0x468(%rbp),%eax
mov    %cl,-0x460(%rbp,%rax,1)
mov    -0x469(%rbp),%cl
mov    -0x464(%rbp),%eax
sub    -0x468(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    %cl,-0x460(%rbp,%rax,1)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1301 <redupe_correct_errata+0x151>
mov    -0x134(%rbp),%eax
mov    %eax,-0x574(%rbp)
movl   $0x0,-0x578(%rbp)
mov    -0x578(%rbp),%eax
cmp    -0x134(%rbp),%eax
jae    13fa <redupe_correct_errata+0x24a>
mov    -0x578(%rbp),%eax
movzbl -0x130(%rbp,%rax,1),%ecx
ff
mov    $0xff,%eax
sub    %ecx,%eax
mov    %eax,-0x57c(%rbp)
xor    %esi,%esi
sub    -0x57c(%rbp),%esi
mov    $0x2,%edi
call   1030 <redupe_gf_pow@plt>
mov    %al,%cl
mov    -0x578(%rbp),%eax
mov    %cl,-0x570(%rbp,%rax,1)
mov    -0x578(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x578(%rbp)
jmp    1398 <redupe_correct_errata+0x1e8>
mov    -0xc(%rbp),%eax
mov    %eax,-0x684(%rbp)
lea    -0x680(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1050 <memset@plt>
movl   $0x0,-0x688(%rbp)
mov    -0x688(%rbp),%eax
cmp    -0x574(%rbp),%eax
jae    15da <redupe_correct_errata+0x42a>
mov    -0x688(%rbp),%eax
movzbl -0x570(%rbp,%rax,1),%edi
ff
call   1070 <redupe_gf_inv@plt>
mov    %al,-0x689(%rbp)
movb   $0x1,-0x68a(%rbp)
movl   $0x0,-0x690(%rbp)
mov    -0x690(%rbp),%eax
cmp    -0x574(%rbp),%eax
jae    14ed <redupe_correct_errata+0x33d>
mov    -0x690(%rbp),%eax
cmp    -0x688(%rbp),%eax
jne    1485 <redupe_correct_errata+0x2d5>
jmp    14d9 <redupe_correct_errata+0x329>
mov    -0x689(%rbp),%cl
mov    -0x690(%rbp),%eax
movzbl %cl,%edi
movzbl -0x570(%rbp,%rax,1),%esi
ff
call   10d0 <redupe_gf_mul@plt>
mov    %al,-0x691(%rbp)
mov    $0x1,%edi
movzbl -0x691(%rbp),%esi
call   10a0 <redupe_gf_sub@plt>
mov    %al,-0x691(%rbp)
mov    -0x68a(%rbp),%al
movzbl %al,%edi
movzbl -0x691(%rbp),%esi
call   10d0 <redupe_gf_mul@plt>
mov    %al,-0x68a(%rbp)
mov    -0x690(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x690(%rbp)
jmp    145c <redupe_correct_errata+0x2ac>
mov    -0x464(%rbp),%eax
mov    %eax,-0x354(%rbp)
movl   $0x0,-0x698(%rbp)
mov    -0x698(%rbp),%eax
cmp    -0x464(%rbp),%eax
jae    154e <redupe_correct_errata+0x39e>
mov    -0x698(%rbp),%eax
mov    -0x460(%rbp,%rax,1),%cl
mov    -0x354(%rbp),%eax
sub    -0x698(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    %cl,-0x350(%rbp,%rax,1)
mov    -0x698(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x698(%rbp)
jmp    1503 <redupe_correct_errata+0x353>
lea    -0x350(%rbp),%rdi
mov    -0x354(%rbp),%esi
movzbl -0x689(%rbp),%edx
call   1060 <redupe_gf_poly_eval@plt>
mov    %al,-0x699(%rbp)
mov    -0x688(%rbp),%eax
mov    $0x1,%esi
movzbl -0x570(%rbp,%rax,1),%edi
ff
call   1030 <redupe_gf_pow@plt>
movzbl %al,%edi
movzbl -0x699(%rbp),%esi
call   10d0 <redupe_gf_mul@plt>
mov    %al,-0x699(%rbp)
mov    -0x699(%rbp),%al
movzbl %al,%edi
movzbl -0x68a(%rbp),%esi
call   1040 <redupe_gf_div@plt>
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    -0x688(%rbp),%edx
movzbl (%rax,%rdx,1),%eax
mov    %cl,-0x680(%rbp,%rax,1)
mov    -0x688(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x688(%rbp)
jmp    1420 <redupe_correct_errata+0x270>
mov    -0xc(%rbp),%eax
mov    %eax,-0x354(%rbp)
lea    -0x350(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   1090 <memmove@plt>
lea    -0x350(%rbp),%rdi
mov    -0x354(%rbp),%esi
lea    -0x680(%rbp),%rdx
mov    -0x684(%rbp),%ecx
mov    -0x8(%rbp),%r8
lea    -0x354(%rbp),%r9
call   1080 <redupe_gf_poly_add@plt>
add    $0x6b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<redupe_correct_errata>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x638,%rsp
mov    %r9d,%r13d
mov    %ecx,%r12d
mov    %rdx,%r14
mov    %rdi,0x20(%rsp)
mov    %r9d,%r15d
test   %r9d,%r9d
je     1449 <redupe_correct_errata+0x299>
cmp    $0x8,%r13d
jae    11e8 <redupe_correct_errata+0x38>
xor    %eax,%eax
jmp    1430 <redupe_correct_errata+0x280>
movd   %esi,%xmm0
cmp    $0x10,%r13d
jae    11f9 <redupe_correct_errata+0x49>
xor    %eax,%eax
jmp    13bc <redupe_correct_errata+0x20c>
mov    %r15d,%eax
and    $0xfffffff0,%eax
pshufd $0x0,%xmm0,%xmm1
lea    -0x10(%rax),%rcx
mov    %rcx,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1ae6 <redupe_correct_errata+0x936>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
pcmpeqd %xmm2,%xmm2
movdqa 0xdcf(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%r8,%rcx,1),%xmm6
movdqa %xmm6,%xmm5
punpcklbw %xmm5,%xmm5
movdqa %xmm5,%xmm4
punpcklwd %xmm4,%xmm4
punpckhwd %xmm5,%xmm5
punpckhbw %xmm6,%xmm6
movdqa %xmm6,%xmm7
punpcklwd %xmm7,%xmm7
punpckhwd %xmm6,%xmm6
pxor   %xmm2,%xmm6
pxor   %xmm2,%xmm7
pxor   %xmm2,%xmm5
pxor   %xmm2,%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm1,%xmm5
paddd  %xmm1,%xmm7
paddd  %xmm1,%xmm6
pand   %xmm3,%xmm6
pand   %xmm3,%xmm7
packuswb %xmm6,%xmm7
pand   %xmm3,%xmm5
pand   %xmm3,%xmm4
packuswb %xmm5,%xmm4
packuswb %xmm7,%xmm4
movdqa %xmm4,0x230(%rsp,%rcx,1)
movdqu 0x10(%r8,%rcx,1),%xmm6
movdqa %xmm6,%xmm5
punpcklbw %xmm5,%xmm5
movdqa %xmm5,%xmm4
punpcklwd %xmm4,%xmm4
punpckhwd %xmm5,%xmm5
punpckhbw %xmm6,%xmm6
movdqa %xmm6,%xmm7
punpcklwd %xmm7,%xmm7
punpckhwd %xmm6,%xmm6
pxor   %xmm2,%xmm6
pxor   %xmm2,%xmm7
pxor   %xmm2,%xmm5
pxor   %xmm2,%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm1,%xmm5
paddd  %xmm1,%xmm7
paddd  %xmm1,%xmm6
pand   %xmm3,%xmm6
pand   %xmm3,%xmm7
packuswb %xmm6,%xmm7
pand   %xmm3,%xmm5
pand   %xmm3,%xmm4
packuswb %xmm5,%xmm4
packuswb %xmm7,%xmm4
movdqa %xmm4,0x240(%rsp,%rcx,1)
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1240 <redupe_correct_errata+0x90>
test   $0x1,%dl
je     13ad <redupe_correct_errata+0x1fd>
movdqu (%r8,%rcx,1),%xmm4
movdqa %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
movdqa %xmm3,%xmm2
punpcklwd %xmm2,%xmm2
punpckhwd %xmm3,%xmm3
punpckhbw %xmm4,%xmm4
movdqa %xmm4,%xmm5
punpcklwd %xmm5,%xmm5
punpckhwd %xmm4,%xmm4
pcmpeqd %xmm6,%xmm6
pxor   %xmm6,%xmm4
pxor   %xmm6,%xmm5
pxor   %xmm6,%xmm3
pxor   %xmm6,%xmm2
paddd  %xmm1,%xmm2
paddd  %xmm1,%xmm3
paddd  %xmm1,%xmm5
paddd  %xmm1,%xmm4
movdqa 0xc78(%rip),%xmm1
pand   %xmm1,%xmm4
pand   %xmm1,%xmm5
packuswb %xmm4,%xmm5
pand   %xmm1,%xmm3
pand   %xmm1,%xmm2
packuswb %xmm3,%xmm2
packuswb %xmm5,%xmm2
movdqa %xmm2,0x230(%rsp,%rcx,1)
cmp    %r15,%rax
je     1449 <redupe_correct_errata+0x299>
test   $0x8,%r15b
je     1430 <redupe_correct_errata+0x280>
mov    %rax,%rcx
mov    %r15d,%eax
and    $0xfffffff8,%eax
pshufd $0x0,%xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
movdqa 0xc2a(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
movq   (%r8,%rcx,1),%xmm3
punpcklbw %xmm3,%xmm3
movdqa %xmm3,%xmm4
punpcklwd %xmm4,%xmm4
punpckhwd %xmm3,%xmm3
pxor   %xmm1,%xmm3
pxor   %xmm1,%xmm4
paddd  %xmm0,%xmm4
paddd  %xmm0,%xmm3
pand   %xmm2,%xmm3
pand   %xmm2,%xmm4
packuswb %xmm3,%xmm4
packuswb %xmm4,%xmm4
movq   %xmm4,0x230(%rsp,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    13e0 <redupe_correct_errata+0x230>
cmp    %r15,%rax
je     1449 <redupe_correct_errata+0x299>
nopl   (%rax)
movzbl (%r8,%rax,1),%ecx
not    %ecx
add    %esi,%ecx
mov    %cl,0x230(%rsp,%rax,1)
add    $0x1,%rax
cmp    %rax,%r15
jne    1430 <redupe_correct_errata+0x280>
mov    %r8,0x28(%rsp)
mov    %esi,0x18(%rsp)
movl   $0x0,0x14(%rsp)
lea    0x230(%rsp),%rdi
lea    0x530(%rsp),%rdx
lea    0x14(%rsp),%rcx
mov    %r13d,%esi
call   10c0 <redupe_find_errata_locator@plt>
mov    %r12d,0x10(%rsp)
test   %r12d,%r12d
je     167c <redupe_correct_errata+0x4cc>
mov    %r12d,%r9d
cmp    $0x8,%r12d
jae    1495 <redupe_correct_errata+0x2e5>
xor    %ecx,%ecx
jmp    15bd <redupe_correct_errata+0x40d>
lea    -0x1(%r9),%rsi
lea    -0x1(%r12),%edx
xor    %ecx,%ecx
cmp    %esi,%edx
jb     15bd <redupe_correct_errata+0x40d>
shr    $0x20,%rsi
jne    15bd <redupe_correct_errata+0x40d>
cmp    $0x20,%r12d
jae    14bf <redupe_correct_errata+0x30f>
xor    %ecx,%ecx
jmp    156c <redupe_correct_errata+0x3bc>
mov    %r9d,%ecx
and    $0xffffffe0,%ecx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu (%r14,%rsi,1),%xmm1
movdqu 0x10(%r14,%rsi,1),%xmm2
mov    %edx,%edi
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 %xmm1,0x121(%rsp,%rdi,1)
movdqa %xmm2,%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm1,%xmm2
movdqu %xmm2,0x111(%rsp,%rdi,1)
add    $0x20,%rsi
add    $0xffffffe0,%edx
cmp    %rsi,%rcx
jne    14d0 <redupe_correct_errata+0x320>
cmp    %r9,%rcx
je     167c <redupe_correct_errata+0x4cc>
test   $0x18,%r9b
je     15bd <redupe_correct_errata+0x40d>
mov    %rcx,%rdx
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
mov    %edx,%esi
not    %esi
add    %r12d,%esi
pxor   %xmm0,%xmm0
movq   (%r14,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
mov    %esi,%edi
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x129(%rsp,%rdi,1)
add    $0x8,%rdx
add    $0xfffffff8,%esi
cmp    %rdx,%rcx
jne    1580 <redupe_correct_errata+0x3d0>
cmp    %r9,%rcx
je     167c <redupe_correct_errata+0x4cc>
mov    %rcx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rsi
and    $0x3,%rsi
je     15fb <redupe_correct_errata+0x44b>
mov    %ecx,%edi
not    %edi
add    %r12d,%edi
cs nopw 0x0(%rax,%rax,1)
movzbl (%r14,%rcx,1),%ebx
mov    %edi,%edx
mov    %bl,0x130(%rsp,%rdx,1)
add    $0x1,%rcx
add    $0xffffffff,%edi
add    $0xffffffffffffffff,%rsi
jne    15e0 <redupe_correct_errata+0x430>
cmp    $0x3,%r8
jb     167c <redupe_correct_errata+0x4cc>
mov    $0xfffffffc,%edx
sub    %ecx,%edx
mov    $0xfffffffd,%esi
sub    %ecx,%esi
mov    %ecx,%edi
not    %edi
mov    $0xfffffffe,%ebx
sub    %ecx,%ebx
nopw   0x0(%rax,%rax,1)
movzbl (%r14,%rcx,1),%eax
lea    (%r9,%rdi,1),%ebp
mov    %al,0x130(%rsp,%rbp,1)
movzbl 0x1(%r14,%rcx,1),%eax
lea    (%rbx,%r9,1),%ebp
mov    %al,0x130(%rsp,%rbp,1)
movzbl 0x2(%r14,%rcx,1),%eax
lea    (%rsi,%r9,1),%ebp
mov    %al,0x130(%rsp,%rbp,1)
movzbl 0x3(%r14,%rcx,1),%eax
lea    (%rdx,%r9,1),%ebp
mov    %al,0x130(%rsp,%rbp,1)
add    $0x4,%rcx
add    $0xfffffffffffffffc,%rdx
add    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rdi
add    $0xfffffffffffffffc,%rbx
cmp    %rcx,%r9
jne    1620 <redupe_correct_errata+0x470>
movl   $0x0,0xc(%rsp)
mov    0x14(%rsp),%ecx
lea    -0x1(%rcx),%r8d
lea    0xc(%rsp),%rax
mov    %rax,(%rsp)
lea    0x130(%rsp),%rdi
lea    0x530(%rsp),%rdx
lea    0x30(%rsp),%r9
mov    %r12d,%esi
call   10b0 <redupe_find_error_evaluator@plt>
mov    0xc(%rsp),%r8d
cmp    $0x2,%r8
jb     1731 <redupe_correct_errata+0x581>
mov    %r8,%rcx
shr    %rcx
cmp    $0x1,%ecx
jne    16cc <redupe_correct_errata+0x51c>
xor    %edx,%edx
jmp    1715 <redupe_correct_errata+0x565>
mov    %ecx,%esi
and    $0xfffffffe,%esi
lea    -0x2(%r8),%edi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl 0x30(%rsp,%rdx,1),%ebx
lea    0x1(%rdi),%ebp
movzbl 0x30(%rsp,%rbp,1),%eax
mov    %al,0x30(%rsp,%rdx,1)
mov    %bl,0x30(%rsp,%rbp,1)
movzbl 0x31(%rsp,%rdx,1),%eax
mov    %edi,%ebp
movzbl 0x30(%rsp,%rbp,1),%ebx
mov    %bl,0x31(%rsp,%rdx,1)
mov    %al,0x30(%rsp,%rbp,1)
add    $0x2,%rdx
add    $0xfffffffe,%edi
cmp    %rdx,%rsi
jne    16e0 <redupe_correct_errata+0x530>
test   $0x1,%cl
je     1731 <redupe_correct_errata+0x581>
mov    0x30(%rsp,%rdx,1),%cl
mov    %edx,%esi
not    %esi
add    %r8d,%esi
mov    0x30(%rsp,%rsi,1),%al
mov    %al,0x30(%rsp,%rdx,1)
mov    %cl,0x30(%rsp,%rsi,1)
test   %r13d,%r13d
je     1a82 <redupe_correct_errata+0x8d2>
xor    %ebx,%ebx
nopl   0x0(%rax)
movzbl 0x230(%rsp,%rbx,1),%esi
add    $0xffffff01,%esi
mov    $0x2,%edi
call   1030 <redupe_gf_pow@plt>
mov    %al,0x430(%rsp,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1740 <redupe_correct_errata+0x590>
lea    0x330(%rsp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1050 <memset@plt>
test   %r13d,%r13d
je     1a96 <redupe_correct_errata+0x8e6>
xor    %r13d,%r13d
jmp    17e8 <redupe_correct_errata+0x638>
nopw   0x0(%rax,%rax,1)
movzbl %r12b,%edx
lea    0x130(%rsp),%rdi
call   1060 <redupe_gf_poly_eval@plt>
mov    %eax,%r12d
mov    0x1c(%rsp),%edi
mov    $0x1,%esi
call   1030 <redupe_gf_pow@plt>
movzbl %r12b,%esi
movzbl %al,%edi
call   10d0 <redupe_gf_mul@plt>
movzbl %al,%edi
movzbl %r14b,%esi
call   1040 <redupe_gf_div@plt>
mov    0x28(%rsp),%rcx
movzbl (%rcx,%r13,1),%ecx
mov    %al,0x330(%rsp,%rcx,1)
add    $0x1,%r13
cmp    %r15,%r13
je     1a96 <redupe_correct_errata+0x8e6>
movzbl 0x430(%rsp,%r13,1),%edi
mov    %edi,0x1c(%rsp)
call   1070 <redupe_gf_inv@plt>
mov    %eax,%r12d
mov    $0x1,%r14b
xor    %ebp,%ebp
jmp    1819 <redupe_correct_errata+0x669>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %rbp,%r15
je     1850 <redupe_correct_errata+0x6a0>
cmp    %rbp,%r13
je     1810 <redupe_correct_errata+0x660>
movzbl 0x430(%rsp,%rbp,1),%esi
movzbl %r12b,%edi
call   10d0 <redupe_gf_mul@plt>
movzbl %al,%esi
mov    $0x1,%edi
call   10a0 <redupe_gf_sub@plt>
movzbl %al,%esi
movzbl %r14b,%edi
call   10d0 <redupe_gf_mul@plt>
mov    %eax,%r14d
jmp    1810 <redupe_correct_errata+0x660>
nopl   (%rax)
mov    0xc(%rsp),%esi
mov    %esi,0x10(%rsp)
test   %rsi,%rsi
je     1790 <redupe_correct_errata+0x5e0>
cmp    $0x8,%esi
jae    1940 <redupe_correct_errata+0x790>
xor    %eax,%eax
mov    %rax,%r8
not    %r8
add    %rsi,%r8
mov    %rsi,%rdx
and    $0x3,%rdx
je     18ab <redupe_correct_errata+0x6fb>
mov    %eax,%edi
not    %edi
add    %esi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x30(%rsp,%rax,1),%ecx
mov    %edi,%ebp
mov    %cl,0x130(%rsp,%rbp,1)
add    $0x1,%rax
add    $0xffffffff,%edi
add    $0xffffffffffffffff,%rdx
jne    1890 <redupe_correct_errata+0x6e0>
cmp    $0x3,%r8
jb     1790 <redupe_correct_errata+0x5e0>
mov    $0xfffffffc,%ecx
sub    %eax,%ecx
mov    $0xfffffffd,%edx
sub    %eax,%edx
mov    $0xfffffffe,%edi
sub    %eax,%edi
mov    %eax,%ebp
not    %ebp
xchg   %ax,%ax
lea    (%rsi,%rbp,1),%r8d
movzbl 0x30(%rsp,%rax,1),%ebx
movzbl 0x31(%rsp,%rax,1),%r9d
mov    %bl,0x130(%rsp,%r8,1)
lea    (%rdi,%rsi,1),%ebx
mov    %r9b,0x130(%rsp,%rbx,1)
movzbl 0x32(%rsp,%rax,1),%r8d
lea    (%rdx,%rsi,1),%ebx
mov    %r8b,0x130(%rsp,%rbx,1)
movzbl 0x33(%rsp,%rax,1),%r8d
lea    (%rcx,%rsi,1),%ebx
mov    %r8b,0x130(%rsp,%rbx,1)
add    $0x4,%rax
add    $0xfffffffffffffffc,%rcx
add    $0xfffffffffffffffc,%rdx
add    $0xfffffffffffffffc,%rbp
add    $0xfffffffffffffffc,%rdi
cmp    %rax,%rsi
jne    18d0 <redupe_correct_errata+0x720>
jmp    1790 <redupe_correct_errata+0x5e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rsi),%rax
lea    -0x1(%rsi),%ecx
cmp    %eax,%ecx
jb     186a <redupe_correct_errata+0x6ba>
shr    $0x20,%rax
mov    $0x0,%eax
jne    186c <redupe_correct_errata+0x6bc>
cmp    $0x20,%esi
jae    196a <redupe_correct_errata+0x7ba>
xor    %eax,%eax
jmp    1a1f <redupe_correct_errata+0x86f>
mov    %esi,%eax
and    $0xffffffe0,%eax
xor    %edx,%edx
pxor   %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
movdqa 0x30(%rsp,%rdx,1),%xmm0
movdqa 0x40(%rsp,%rdx,1),%xmm1
mov    %ecx,%edi
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqu %xmm0,0x121(%rsp,%rdi,1)
movdqa %xmm1,%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm0,%xmm1
movdqu %xmm1,0x111(%rsp,%rdi,1)
add    $0x20,%rdx
add    $0xffffffe0,%ecx
cmp    %rdx,%rax
jne    1980 <redupe_correct_errata+0x7d0>
cmp    %rsi,%rax
je     1790 <redupe_correct_errata+0x5e0>
test   $0x18,%sil
je     186c <redupe_correct_errata+0x6bc>
mov    %rax,%rcx
mov    %esi,%eax
and    $0xfffffff8,%eax
mov    %ecx,%edx
not    %edx
add    %esi,%edx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   0x30(%rsp,%rcx,1),%xmm0
mov    %edx,%edi
punpcklbw %xmm1,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0x129(%rsp,%rdi,1)
add    $0x8,%rcx
add    $0xfffffff8,%edx
cmp    %rcx,%rax
jne    1a40 <redupe_correct_errata+0x890>
cmp    %rsi,%rax
je     1790 <redupe_correct_errata+0x5e0>
jmp    186c <redupe_correct_errata+0x6bc>
lea    0x330(%rsp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1050 <memset@plt>
mov    0x18(%rsp),%ebx
mov    %ebx,0x10(%rsp)
lea    0x130(%rsp),%r14
mov    %r14,%rdi
mov    0x20(%rsp),%rbp
mov    %rbp,%rsi
mov    %ebx,%edx
call   1090 <memmove@plt>
lea    0x330(%rsp),%rdx
lea    0x10(%rsp),%r9
mov    %r14,%rdi
mov    %ebx,%esi
mov    %ebx,%ecx
mov    %rbp,%r8
call   1080 <redupe_gf_poly_add@plt>
add    $0x638,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    1332 <redupe_correct_errata+0x182>
jmp    13ad <redupe_correct_errata+0x1fd>

LLVM IR (-O0):
define void @redupe_correct_errata(i8* %0, i32 %1, i8* %2, i32 %3, i8* %4, i32 %5) {
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i32
%13 = alloca [256 x i8]
%14 = alloca i32
%15 = alloca i32
%16 = alloca [256 x i8]
%17 = alloca i32
%18 = alloca [256 x i8]
%19 = alloca i32
%20 = alloca i32
%21 = alloca [256 x i8]
%22 = alloca i32
%23 = alloca i32
%24 = alloca i8
%25 = alloca [256 x i8]
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca [256 x i8]
%30 = alloca i32
%31 = alloca i32
%32 = alloca i8
%33 = alloca i8
%34 = alloca i32
%35 = alloca i8
%36 = alloca i32
%37 = alloca i8
store i8* %0, i8** %7
store i32 %1, i32* %8
store i8* %2, i8** %9
store i32 %3, i32* %10
store i8* %4, i8** %11
store i32 %5, i32* %12
%38 = load i32, i32* %12
store i32 %38, i32* %14
store i32 0, i32* %15
br label %39
39: ; preds = %57, %6
%40 = load i32, i32* %15
%41 = load i32, i32* %14
%42 = icmp ult i32 %40, %41
br i1 %42, label %43, label %60
43: ; preds = %39
%44 = load i32, i32* %8
%45 = sub i32 %44, 1
%46 = load i8*, i8** %11
%47 = load i32, i32* %15
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds i8, i8* %46, i64 %48
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = sub i32 %45, %51
%53 = trunc i32 %52 to i8
%54 = load i32, i32* %15
%55 = zext i32 %54 to i64
%56 = getelementptr inbounds [256 x i8], [256 x i8]* %13, i64 0, i64 %55
store i8 %53, i8* %56
br label %57
57: ; preds = %43
%58 = load i32, i32* %15
%59 = add i32 %58, 1
store i32 %59, i32* %15
br label %39
60: ; preds = %39
store i32 0, i32* %17
%61 = getelementptr inbounds [256 x i8], [256 x i8]* %13, i64 0, i64 0
%62 = load i32, i32* %14
%63 = getelementptr inbounds [256 x i8], [256 x i8]* %16, i64 0, i64 0
%64 = call i32 @redupe_find_errata_locator(i8* %61, i32 %62, i8* %63, i32* %17)
%65 = load i32, i32* %10
store i32 %65, i32* %19
store i32 0, i32* %20
br label %66
66: ; preds = %82, %60
%67 = load i32, i32* %20
%68 = load i32, i32* %10
%69 = icmp ult i32 %67, %68
br i1 %69, label %70, label %85
70: ; preds = %66
%71 = load i8*, i8** %9
%72 = load i32, i32* %20
%73 = zext i32 %72 to i64
%74 = getelementptr inbounds i8, i8* %71, i64 %73
%75 = load i8, i8* %74
%76 = load i32, i32* %10
%77 = load i32, i32* %20
%78 = sub i32 %76, %77
%79 = sub i32 %78, 1
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 %80
store i8 %75, i8* %81
br label %82
82: ; preds = %70
%83 = load i32, i32* %20
%84 = add i32 %83, 1
store i32 %84, i32* %20
br label %66
85: ; preds = %66
store i32 0, i32* %22
%86 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%87 = load i32, i32* %19
%88 = getelementptr inbounds [256 x i8], [256 x i8]* %16, i64 0, i64 0
%89 = load i32, i32* %17
%90 = load i32, i32* %17
%91 = sub i32 %90, 1
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %21, i64 0, i64 0
%93 = call i32 @redupe_find_error_evaluator(i8* %86, i32 %87, i8* %88, i32 %89, i32 %91, i8* %92, i32* %22)
store i32 0, i32* %23
br label %94
94: ; preds = %121, %85
%95 = load i32, i32* %23
%96 = load i32, i32* %22
%97 = udiv i32 %96, 2
%98 = icmp ult i32 %95, %97
br i1 %98, label %99, label %124
99: ; preds = %94
%100 = load i32, i32* %23
%101 = zext i32 %100 to i64
%102 = getelementptr inbounds [256 x i8], [256 x i8]* %21, i64 0, i64 %101
%103 = load i8, i8* %102
store i8 %103, i8* %24
%104 = load i32, i32* %22
%105 = load i32, i32* %23
%106 = sub i32 %104, %105
%107 = sub i32 %106, 1
%108 = zext i32 %107 to i64
%109 = getelementptr inbounds [256 x i8], [256 x i8]* %21, i64 0, i64 %108
%110 = load i8, i8* %109
%111 = load i32, i32* %23
%112 = zext i32 %111 to i64
%113 = getelementptr inbounds [256 x i8], [256 x i8]* %21, i64 0, i64 %112
store i8 %110, i8* %113
%114 = load i8, i8* %24
%115 = load i32, i32* %22
%116 = load i32, i32* %23
%117 = sub i32 %115, %116
%118 = sub i32 %117, 1
%119 = zext i32 %118 to i64
%120 = getelementptr inbounds [256 x i8], [256 x i8]* %21, i64 0, i64 %119
store i8 %114, i8* %120
br label %121
121: ; preds = %99
%122 = load i32, i32* %23
%123 = add i32 %122, 1
store i32 %123, i32* %23
br label %94
124: ; preds = %94
%125 = load i32, i32* %14
store i32 %125, i32* %26
store i32 0, i32* %27
br label %126
126: ; preds = %143, %124
%127 = load i32, i32* %27
%128 = load i32, i32* %14
%129 = icmp ult i32 %127, %128
br i1 %129, label %130, label %146
130: ; preds = %126
%131 = load i32, i32* %27
%132 = zext i32 %131 to i64
%133 = getelementptr inbounds [256 x i8], [256 x i8]* %13, i64 0, i64 %132
%134 = load i8, i8* %133
%135 = zext i8 %134 to i32
%136 = sub nsw i32 255, %135
store i32 %136, i32* %28
%137 = load i32, i32* %28
%138 = sub nsw i32 0, %137
%139 = call zeroext i8 @redupe_gf_pow(i8 zeroext 2, i32 %138)
%140 = load i32, i32* %27
%141 = zext i32 %140 to i64
%142 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 %141
store i8 %139, i8* %142
br label %143
143: ; preds = %130
%144 = load i32, i32* %27
%145 = add i32 %144, 1
store i32 %145, i32* %27
br label %126
146: ; preds = %126
%147 = load i32, i32* %8
store i32 %147, i32* %30
%148 = getelementptr inbounds [256 x i8], [256 x i8]* %29, i64 0, i64 0
%149 = call i32 @memset(i8* %148, i32 0, i32 256)
store i32 0, i32* %31
br label %150
150: ; preds = %226, %146
%151 = load i32, i32* %31
%152 = load i32, i32* %26
%153 = icmp ult i32 %151, %152
br i1 %153, label %154, label %229
154: ; preds = %150
%155 = load i32, i32* %31
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 %156
%158 = load i8, i8* %157
%159 = call zeroext i8 @redupe_gf_inv(i8 zeroext %158)
store i8 %159, i8* %32
store i8 1, i8* %33
store i32 0, i32* %34
br label %160
160: ; preds = %181, %154
%161 = load i32, i32* %34
%162 = load i32, i32* %26
%163 = icmp ult i32 %161, %162
br i1 %163, label %164, label %184
164: ; preds = %160
%165 = load i32, i32* %34
%166 = load i32, i32* %31
%167 = icmp eq i32 %165, %166
br i1 %167, label %168, label %169
168: ; preds = %164
br label %181
169: ; preds = %164
%170 = load i8, i8* %32
%171 = load i32, i32* %34
%172 = zext i32 %171 to i64
%173 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 %172
%174 = load i8, i8* %173
%175 = call zeroext i8 @redupe_gf_mul(i8 zeroext %170, i8 zeroext %174)
store i8 %175, i8* %35
%176 = load i8, i8* %35
%177 = call zeroext i8 @redupe_gf_sub(i32 1, i8 zeroext %176)
store i8 %177, i8* %35
%178 = load i8, i8* %33
%179 = load i8, i8* %35
%180 = call zeroext i8 @redupe_gf_mul(i8 zeroext %178, i8 zeroext %179)
store i8 %180, i8* %33
br label %181
181: ; preds = %169, %168
%182 = load i32, i32* %34
%183 = add i32 %182, 1
store i32 %183, i32* %34
br label %160
184: ; preds = %160
%185 = load i32, i32* %22
store i32 %185, i32* %19
store i32 0, i32* %36
br label %186
186: ; preds = %201, %184
%187 = load i32, i32* %36
%188 = load i32, i32* %22
%189 = icmp ult i32 %187, %188
br i1 %189, label %190, label %204
190: ; preds = %186
%191 = load i32, i32* %36
%192 = zext i32 %191 to i64
%193 = getelementptr inbounds [256 x i8], [256 x i8]* %21, i64 0, i64 %192
%194 = load i8, i8* %193
%195 = load i32, i32* %19
%196 = load i32, i32* %36
%197 = sub i32 %195, %196
%198 = sub i32 %197, 1
%199 = zext i32 %198 to i64
%200 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 %199
store i8 %194, i8* %200
br label %201
201: ; preds = %190
%202 = load i32, i32* %36
%203 = add i32 %202, 1
store i32 %203, i32* %36
br label %186
204: ; preds = %186
%205 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%206 = load i32, i32* %19
%207 = load i8, i8* %32
%208 = call zeroext i8 @redupe_gf_poly_eval(i8* %205, i32 %206, i8 zeroext %207)
store i8 %208, i8* %37
%209 = load i32, i32* %31
%210 = zext i32 %209 to i64
%211 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 %210
%212 = load i8, i8* %211
%213 = call zeroext i8 @redupe_gf_pow(i8 zeroext %212, i32 1)
%214 = load i8, i8* %37
%215 = call zeroext i8 @redupe_gf_mul(i8 zeroext %213, i8 zeroext %214)
store i8 %215, i8* %37
%216 = load i8, i8* %37
%217 = load i8, i8* %33
%218 = call zeroext i8 @redupe_gf_div(i8 zeroext %216, i8 zeroext %217)
%219 = load i8*, i8** %11
%220 = load i32, i32* %31
%221 = zext i32 %220 to i64
%222 = getelementptr inbounds i8, i8* %219, i64 %221
%223 = load i8, i8* %222
%224 = zext i8 %223 to i64
%225 = getelementptr inbounds [256 x i8], [256 x i8]* %29, i64 0, i64 %224
store i8 %218, i8* %225
br label %226
226: ; preds = %204
%227 = load i32, i32* %31
%228 = add i32 %227, 1
store i32 %228, i32* %31
br label %150
229: ; preds = %150
%230 = load i32, i32* %8
store i32 %230, i32* %19
%231 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%232 = load i8*, i8** %7
%233 = load i32, i32* %8
%234 = call i32 @memmove(i8* %231, i8* %232, i32 %233)
%235 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%236 = load i32, i32* %19
%237 = getelementptr inbounds [256 x i8], [256 x i8]* %29, i64 0, i64 0
%238 = load i32, i32* %30
%239 = load i8*, i8** %7
%240 = call i32 @redupe_gf_poly_add(i8* %235, i32 %236, i8* %237, i32 %238, i8* %239, i32* %19)
ret void
}

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