#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 */

/* Variables and functions */
unsigned int mpy_mod_gf(unsigned int, unsigned int);
void syndrome(unsigned int select_4_8, unsigned char *ecc, unsigned int syn[]) {
  unsigned int k, l, t;
  unsigned int alpha_bit, R_bit;
  int ecc_pos, ecc_min;
  unsigned int pow_alpha[8] = {0x0002, 0x0008, 0x0020, 0x0080,
                               0x0200, 0x0800, 0x001B, 0x006C};
  if (select_4_8 == 0) {
    t = 4;
    ecc_pos = 55;
    ecc_min = 4;
  } else {
    t = 8;
    ecc_pos = 103;
    ecc_min = 0;
  }
  R_bit = ((ecc[ecc_pos / 8] >> (7 - ecc_pos % 8)) & 1);
  ecc_pos--;
  for (k = 0; k < t; k++)
    syn[2 * k] = R_bit;
  while (ecc_pos >= ecc_min) {
    R_bit = ((ecc[ecc_pos / 8] >> (7 - ecc_pos % 8)) & 1);
    ecc_pos--;
    for (k = 0; k < t; k++) {
      if (R_bit == 1)
        syn[2 * k] ^= pow_alpha[k];
      for (l = 0; l < (2 * k + 1); l++) {
        alpha_bit = (pow_alpha[k] >> 12) & 1;
        pow_alpha[k] = (pow_alpha[k] << 1) & 0x1FFF;
        if (alpha_bit == 1)
          pow_alpha[k] ^= 0x001B;
      }
    }
  }
  for (k = 0; k < t; k++)
    syn[2 * k + 1] = mpy_mod_gf(syn[k], syn[k]);
}


x86 assembly (clang, -O0):
<syndrome>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    0xed3(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0xed0(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    0xecd(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    0xeca(%rip),%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    1176 <syndrome+0x66>
movl   $0x4,-0x24(%rbp)
movl   $0x37,-0x30(%rbp)
movl   $0x4,-0x34(%rbp)
jmp    118b <syndrome+0x7b>
movl   $0x8,-0x24(%rbp)
movl   $0x67,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
mov    -0x30(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x64(%rbp),%eax
mov    $0x7,%ecx
sub    %edx,%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1207 <syndrome+0xf7>
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11db <syndrome+0xcb>
jmp    120c <syndrome+0xfc>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     131c <syndrome+0x20c>
mov    -0x10(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x30(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x74(%rbp)
mov    -0x30(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x74(%rbp),%eax
mov    $0x7,%ecx
sub    %edx,%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1317 <syndrome+0x207>
cmpl   $0x1,-0x2c(%rbp)
jne    1297 <syndrome+0x187>
mov    -0x1c(%rbp),%eax
mov    -0x60(%rbp,%rax,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
mov    %ecx,%ecx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jae    1304 <syndrome+0x1f4>
mov    -0x1c(%rbp),%eax
mov    -0x60(%rbp,%rax,4),%eax
shr    $0xc,%eax
and    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x60(%rbp,%rax,4),%ecx
shl    $0x1,%ecx
and    $0x1fff,%ecx
mov    -0x1c(%rbp),%eax
mov    %ecx,-0x60(%rbp,%rax,4)
cmpl   $0x1,-0x28(%rbp)
jne    12f1 <syndrome+0x1e1>
mov    -0x1c(%rbp),%eax
mov    -0x60(%rbp,%rax,4),%ecx
xor    $0x1b,%ecx
mov    %ecx,-0x60(%rbp,%rax,4)
jmp    12f6 <syndrome+0x1e6>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    129e <syndrome+0x18e>
jmp    1309 <syndrome+0x1f9>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1268 <syndrome+0x158>
jmp    120c <syndrome+0xfc>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    136a <syndrome+0x25a>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    (%rax,%rcx,4),%esi
call   1030 <mpy_mod_gf@plt>
mov    %eax,%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1323 <syndrome+0x213>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<syndrome>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rdx,%r14
movaps 0xeed(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xed1(%rip),%xmm0
movaps %xmm0,(%rsp)
xor    %eax,%eax
test   %edi,%edi
setne  %al
lea    0x4(,%rax,4),%r15
mov    $0x37,%eax
mov    $0x67,%r9d
cmove  %eax,%r9d
mov    %r9,%rax
shr    $0x3,%rax
movzbl (%rsi,%rax,1),%eax
and    $0x1,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,(%r14,%rcx,8)
mov    %eax,0x8(%r14,%rcx,8)
mov    %eax,0x10(%r14,%rcx,8)
mov    %eax,0x18(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1170 <syndrome+0x60>
xor    %r8d,%r8d
test   %edi,%edi
sete   %r8b
shl    $0x2,%r8d
jmp    11a9 <syndrome+0x99>
nopl   0x0(%rax,%rax,1)
cmp    %r8d,%r9d
jle    1275 <syndrome+0x165>
mov    %r9d,%eax
lea    -0x1(%rax),%r9d
lea    0x6(%rax),%ecx
test   %r9d,%r9d
cmovns %r9d,%ecx
mov    %ecx,%edx
sar    $0x3,%edx
and    $0xfffffff8,%ecx
neg    %ecx
add    %ecx,%eax
add    $0xffffffff,%eax
mov    $0x7,%cl
sub    %al,%cl
mov    $0x1,%r10d
shl    %cl,%r10d
movzbl (%rsi,%rdx,1),%eax
mov    $0x1,%r11d
and    %eax,%r10d
xor    %edx,%edx
jmp    1200 <syndrome+0xf0>
nopw   0x0(%rax,%rax,1)
mov    %eax,(%rsp,%rdx,4)
add    $0x1,%rdx
add    $0x2,%r11d
cmp    %r15,%rdx
je     11a0 <syndrome+0x90>
mov    (%rsp,%rdx,4),%eax
test   %r10d,%r10d
je     120c <syndrome+0xfc>
xor    %eax,(%r14,%rdx,8)
test   $0x7fffffff,%edx
je     1252 <syndrome+0x142>
mov    %edx,%ebx
and    $0x3fffffff,%ebx
add    %ebx,%ebx
xchg   %ax,%ax
lea    (%rax,%rax,1),%edi
and    $0x1ffe,%edi
mov    %edi,%ecx
xor    $0x1b,%ecx
test   $0x1000,%eax
cmove  %edi,%ecx
lea    (%rcx,%rcx,1),%edi
and    $0x1ffe,%edi
mov    %edi,%eax
xor    $0x1b,%eax
test   $0x1000,%ecx
cmove  %edi,%eax
add    $0xfffffffe,%ebx
jne    1220 <syndrome+0x110>
test   $0x1,%r11b
je     11f0 <syndrome+0xe0>
lea    (%rax,%rax,1),%ecx
and    $0x1ffe,%ecx
mov    %ecx,%edi
xor    $0x1b,%edi
test   $0x1000,%eax
cmove  %ecx,%edi
mov    %edi,%eax
jmp    11f0 <syndrome+0xe0>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbx,4),%edi
mov    %edi,%esi
call   1030 <mpy_mod_gf@plt>
mov    %eax,0x4(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1280 <syndrome+0x170>
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@__const.syndrome.pow_alpha = [8 x i32] [i32 2, i32 8, i32 32, i32 128, i32 512, i32 2048, i32 27, i32 108]
define void @syndrome(i32 %0, i8* %1, i32* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [8 x i32]
store i32 %0, i32* %4
store i8* %1, i8** %5
store i32* %2, i32** %6
%15 = bitcast [8 x i32]* %14 to i8*
%16 = load i32, i32* %4
%17 = icmp eq i32 %16, 0
br i1 %17, label %18, label %19
18: ; preds = %3
store i32 4, i32* %9
store i32 55, i32* %12
store i32 4, i32* %13
br label %20
19: ; preds = %3
store i32 8, i32* %9
store i32 103, i32* %12
store i32 0, i32* %13
br label %20
20: ; preds = %19, %18
%21 = load i8*, i8** %5
%22 = load i32, i32* %12
%23 = sdiv i32 %22, 8
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %21, i64 %24
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = load i32, i32* %12
%29 = srem i32 %28, 8
%30 = sub nsw i32 7, %29
%31 = ashr i32 %27, %30
%32 = and i32 %31, 1
store i32 %32, i32* %11
%33 = load i32, i32* %12
%34 = add nsw i32 %33, -1
store i32 %34, i32* %12
store i32 0, i32* %7
br label %35
35: ; preds = %46, %20
%36 = load i32, i32* %7
%37 = load i32, i32* %9
%38 = icmp ult i32 %36, %37
br i1 %38, label %39, label %49
39: ; preds = %35
%40 = load i32, i32* %11
%41 = load i32*, i32** %6
%42 = load i32, i32* %7
%43 = mul i32 2, %42
%44 = zext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %41, i64 %44
store i32 %40, i32* %45
br label %46
46: ; preds = %39
%47 = load i32, i32* %7
%48 = add i32 %47, 1
store i32 %48, i32* %7
br label %35
49: ; preds = %35
br label %50
50: ; preds = %127, %49
%51 = load i32, i32* %12
%52 = load i32, i32* %13
%53 = icmp sge i32 %51, %52
br i1 %53, label %54, label %128
54: ; preds = %50
%55 = load i8*, i8** %5
%56 = load i32, i32* %12
%57 = sdiv i32 %56, 8
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %55, i64 %58
%60 = load i8, i8* %59
%61 = zext i8 %60 to i32
%62 = load i32, i32* %12
%63 = srem i32 %62, 8
%64 = sub nsw i32 7, %63
%65 = ashr i32 %61, %64
%66 = and i32 %65, 1
store i32 %66, i32* %11
%67 = load i32, i32* %12
%68 = add nsw i32 %67, -1
store i32 %68, i32* %12
store i32 0, i32* %7
br label %69
69: ; preds = %124, %54
%70 = load i32, i32* %7
%71 = load i32, i32* %9
%72 = icmp ult i32 %70, %71
br i1 %72, label %73, label %127
73: ; preds = %69
%74 = load i32, i32* %11
%75 = icmp eq i32 %74, 1
br i1 %75, label %76, label %88
76: ; preds = %73
%77 = load i32, i32* %7
%78 = zext i32 %77 to i64
%79 = getelementptr inbounds [8 x i32], [8 x i32]* %14, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = load i32*, i32** %6
%82 = load i32, i32* %7
%83 = mul i32 2, %82
%84 = zext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %81, i64 %84
%86 = load i32, i32* %85
%87 = xor i32 %86, %80
store i32 %87, i32* %85
br label %88
88: ; preds = %76, %73
store i32 0, i32* %8
br label %89
89: ; preds = %120, %88
%90 = load i32, i32* %8
%91 = load i32, i32* %7
%92 = mul i32 2, %91
%93 = add i32 %92, 1
%94 = icmp ult i32 %90, %93
br i1 %94, label %95, label %123
95: ; preds = %89
%96 = load i32, i32* %7
%97 = zext i32 %96 to i64
%98 = getelementptr inbounds [8 x i32], [8 x i32]* %14, i64 0, i64 %97
%99 = load i32, i32* %98
%100 = lshr i32 %99, 12
%101 = and i32 %100, 1
store i32 %101, i32* %10
%102 = load i32, i32* %7
%103 = zext i32 %102 to i64
%104 = getelementptr inbounds [8 x i32], [8 x i32]* %14, i64 0, i64 %103
%105 = load i32, i32* %104
%106 = shl i32 %105, 1
%107 = and i32 %106, 8191
%108 = load i32, i32* %7
%109 = zext i32 %108 to i64
%110 = getelementptr inbounds [8 x i32], [8 x i32]* %14, i64 0, i64 %109
store i32 %107, i32* %110
%111 = load i32, i32* %10
%112 = icmp eq i32 %111, 1
br i1 %112, label %113, label %119
113: ; preds = %95
%114 = load i32, i32* %7
%115 = zext i32 %114 to i64
%116 = getelementptr inbounds [8 x i32], [8 x i32]* %14, i64 0, i64 %115
%117 = load i32, i32* %116
%118 = xor i32 %117, 27
store i32 %118, i32* %116
br label %119
119: ; preds = %113, %95
br label %120
120: ; preds = %119
%121 = load i32, i32* %8
%122 = add i32 %121, 1
store i32 %122, i32* %8
br label %89
123: ; preds = %89
br label %124
124: ; preds = %123
%125 = load i32, i32* %7
%126 = add i32 %125, 1
store i32 %126, i32* %7
br label %69
127: ; preds = %69
br label %50
128: ; preds = %50
store i32 0, i32* %7
br label %129
129: ; preds = %151, %128
%130 = load i32, i32* %7
%131 = load i32, i32* %9
%132 = icmp ult i32 %130, %131
br i1 %132, label %133, label %154
133: ; preds = %129
%134 = load i32*, i32** %6
%135 = load i32, i32* %7
%136 = zext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %134, i64 %136
%138 = load i32, i32* %137
%139 = load i32*, i32** %6
%140 = load i32, i32* %7
%141 = zext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %139, i64 %141
%143 = load i32, i32* %142
%144 = call i32 @mpy_mod_gf(i32 %138, i32 %143)
%145 = load i32*, i32** %6
%146 = load i32, i32* %7
%147 = mul i32 2, %146
%148 = add i32 %147, 1
%149 = zext i32 %148 to i64
%150 = getelementptr inbounds i32, i32* %145, i64 %149
store i32 %144, i32* %150
br label %151
151: ; preds = %133
%152 = load i32, i32* %7
%153 = add i32 %152, 1
store i32 %153, i32* %7
br label %129
154: ; preds = %129
ret void
}

LLVM IR (-O2):
@__const.syndrome.pow_alpha = [8 x i32] [i32 2, i32 8, i32 32, i32 128, i32 512, i32 2048, i32 27, i32 108]
define void @syndrome(i32 %0, i8* nocapture %1, i32* nocapture %2) {
%4 = alloca [8 x i32]
%5 = bitcast [8 x i32]* %4 to i8*
%6 = icmp eq i32 %0, 0
%7 = select i1 %6, i64 4, i64 8
%8 = select i1 %6, i32 55, i32 103
%9 = lshr i32 %8, 3
%10 = zext i32 %9 to i64
%11 = getelementptr inbounds i8, i8* %1, i64 %10
%12 = load i8, i8* %11
%13 = and i8 %12, 1
%14 = zext i8 %13 to i32
br label %17
15: ; preds = %17
%16 = select i1 %6, i32 4, i32 0
br label %34
17: ; preds = %17, %3
%18 = phi i64 [ 0, %3 ], [ %30, %17 ]
%19 = shl nuw i64 %18, 1
%20 = getelementptr inbounds i32, i32* %2, i64 %19
store i32 %14, i32* %20
%21 = shl nuw i64 %18, 1
%22 = or i64 %21, 2
%23 = getelementptr inbounds i32, i32* %2, i64 %22
store i32 %14, i32* %23
%24 = shl nuw i64 %18, 1
%25 = or i64 %24, 4
%26 = getelementptr inbounds i32, i32* %2, i64 %25
store i32 %14, i32* %26
%27 = shl nuw i64 %18, 1
%28 = or i64 %27, 6
%29 = getelementptr inbounds i32, i32* %2, i64 %28
store i32 %14, i32* %29
%30 = add nuw nsw i64 %18, 4
%31 = icmp eq i64 %30, %7
br i1 %31, label %15, label %17
32: ; preds = %92
%33 = icmp sgt i32 %36, %16
br i1 %33, label %34, label %97
34: ; preds = %15, %32
%35 = phi i32 [ %8, %15 ], [ %36, %32 ]
%36 = add nsw i32 %35, -1
%37 = sdiv i32 %36, 8
%38 = zext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %1, i64 %38
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = srem i32 %36, 8
%43 = sub nsw i32 7, %42
%44 = shl nuw nsw i32 1, %43
%45 = and i32 %44, %41
%46 = icmp eq i32 %45, 0
br label %47
47: ; preds = %34, %92
%48 = phi i64 [ 0, %34 ], [ %94, %92 ]
%49 = phi i32 [ 1, %34 ], [ %95, %92 ]
%50 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 %48
%51 = load i32, i32* %50
br i1 %46, label %57, label %52
52: ; preds = %47
%53 = shl nuw i64 %48, 1
%54 = getelementptr inbounds i32, i32* %2, i64 %53
%55 = load i32, i32* %54
%56 = xor i32 %55, %51
store i32 %56, i32* %54
br label %57
57: ; preds = %47, %52
%58 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 %48
%59 = and i32 %49, 1
%60 = and i64 %48, 2147483647
%61 = icmp eq i64 %60, 0
br i1 %61, label %81, label %62
62: ; preds = %57
%63 = and i32 %49, 2147483646
br label %64
64: ; preds = %64, %62
%65 = phi i32 [ %51, %62 ], [ %78, %64 ]
%66 = phi i32 [ 0, %62 ], [ %79, %64 ]
%67 = shl i32 %65, 1
%68 = and i32 %67, 8190
%69 = and i32 %65, 4096
%70 = icmp eq i32 %69, 0
%71 = xor i32 %68, 27
%72 = select i1 %70, i32 %68, i32 %71
%73 = shl nuw nsw i32 %72, 1
%74 = and i32 %73, 8190
%75 = and i32 %72, 4096
%76 = icmp eq i32 %75, 0
%77 = xor i32 %74, 27
%78 = select i1 %76, i32 %74, i32 %77
%79 = add i32 %66, 2
%80 = icmp eq i32 %79, %63
br i1 %80, label %81, label %64
81: ; preds = %64, %57
%82 = phi i32 [ undef, %57 ], [ %78, %64 ]
%83 = phi i32 [ %51, %57 ], [ %78, %64 ]
%84 = icmp eq i32 %59, 0
br i1 %84, label %92, label %85
85: ; preds = %81
%86 = shl i32 %83, 1
%87 = and i32 %86, 8190
%88 = and i32 %83, 4096
%89 = icmp eq i32 %88, 0
%90 = xor i32 %87, 27
%91 = select i1 %89, i32 %87, i32 %90
br label %92
92: ; preds = %81, %85
%93 = phi i32 [ %82, %81 ], [ %91, %85 ]
store i32 %93, i32* %58
%94 = add nuw nsw i64 %48, 1
%95 = add nuw nsw i32 %49, 2
%96 = icmp eq i64 %94, %7
br i1 %96, label %32, label %47
97: ; preds = %32, %97
%98 = phi i64 [ %105, %97 ], [ 0, %32 ]
%99 = getelementptr inbounds i32, i32* %2, i64 %98
%100 = load i32, i32* %99
%101 = tail call i32 @mpy_mod_gf(i32 %100, i32 %100)
%102 = shl nuw i64 %98, 1
%103 = or i64 %102, 1
%104 = getelementptr inbounds i32, i32* %2, i64 %103
store i32 %101, i32* %104
%105 = add nuw nsw i64 %98, 1
%106 = icmp eq i64 %105, %7
br i1 %106, label %107, label %97
107: ; preds = %97
ret void
}