#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 */
int log2_approx(unsigned int);
int /*<<< orphan*/ msg(char *, unsigned int, unsigned int, unsigned char);
int /*<<< orphan*/ pset_taus_seed(unsigned int);
unsigned int ptaus();
int rate_matching(unsigned int N_coded, unsigned int N_input,
                  unsigned char *inPtr, unsigned char N_bps, unsigned int off) {
  unsigned int i, j, U, Umod, rep_flag = 0;
  unsigned int N_coded2, N_input2, Mod_input2;
  int N_punctured;
  if ((9 * N_coded < (N_input << 2)) || (N_input < (N_coded >> 1))) {
    msg("[PHY][CODING] Rate matching parameter error (N_coded %d, N_input %d, "
        "N_bps %d), exiting\n",
        N_coded, N_input, N_bps);
    return (-1);
  }
  for (i = 0; i < N_input; i++)
    inPtr[i] |= 0x80;
  i = 0;
  N_coded2 = N_coded / N_bps;
  pset_taus_seed(off);
  N_input2 = N_input / N_bps;
  N_punctured = N_input2 - N_coded2;
  if (N_punctured < 0) {
    N_punctured = -N_punctured;
    rep_flag = 1;
  }
  Mod_input2 = (1 << (1 + log2_approx(N_input2))) - 1;
  while (i < N_punctured) {
    do {
      U = ptaus();
      Umod = U & Mod_input2;
      if ((Umod < N_input2) &&
          (((inPtr[Umod] & 0x80) == 0) || ((inPtr[Umod] & 0xc0) == 0xc0)))
        Umod = N_input2;
    } while (Umod >= N_input2);
    for (j = 0; j < N_bps; j++) {
      if (rep_flag == 0)
        inPtr[Umod + (j * N_input2)] &= 0x7f;
      else
        inPtr[Umod + (j * N_input2)] |= 0xc0;
    }
    i++;
  }
  return (0);
}


x86 assembly (clang, -O0):
<rate_matching>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %cl,%al
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %al,-0x19(%rbp)
mov    %r8d,-0x20(%rbp)
movl   $0x0,-0x34(%rbp)
imul   $0x9,-0x8(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jb     1185 <rate_matching+0x45>
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
jae    11a7 <rate_matching+0x67>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0xe6e(%rip),%rdi
movzbl -0x19(%rbp),%ecx
call   1060 <msg@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1346 <rate_matching+0x206>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    11dc <rate_matching+0x9c>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
or     $0x80,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ae <rate_matching+0x6e>
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%eax
movzbl -0x19(%rbp),%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%edi
call   1050 <pset_taus_seed@plt>
mov    -0xc(%rbp),%eax
movzbl -0x19(%rbp),%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    1229 <rate_matching+0xe9>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x3c(%rbp),%edi
call   1030 <log2_approx@plt>
mov    %eax,%ecx
add    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x44(%rbp),%eax
jae    133f <rate_matching+0x1ff>
jmp    1254 <rate_matching+0x114>
mov    $0x0,%al
call   1040 <ptaus@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
and    -0x40(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jae    12ad <rate_matching+0x16d>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     12a7 <rate_matching+0x167>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
and    $0xc0,%eax
cmp    $0xc0,%eax
jne    12ad <rate_matching+0x16d>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    12b2 <rate_matching+0x172>
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jae    1254 <rate_matching+0x114>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
movzbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jae    1331 <rate_matching+0x1f1>
cmpl   $0x0,-0x34(%rbp)
jne    12ff <rate_matching+0x1bf>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edx
and    $0x7f,%edx
mov    %dl,(%rax,%rcx,1)
jmp    131e <rate_matching+0x1de>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edx
or     $0xc0,%edx
mov    %dl,(%rax,%rcx,1)
jmp    1323 <rate_matching+0x1e3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12c5 <rate_matching+0x185>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1243 <rate_matching+0x103>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rate_matching>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,0x4(%rsp)
mov    %esi,%ebx
mov    %edi,%eax
mov    %edi,%ecx
shr    %ecx
cmp    %esi,%ecx
ja     1185 <rate_matching+0x45>
mov    %rdx,%r14
lea    (%rax,%rax,8),%ecx
lea    0x0(,%rbx,4),%edx
cmp    %edx,%ecx
jb     1185 <rate_matching+0x45>
test   %ebx,%ebx
je     129e <rate_matching+0x15e>
mov    %ebx,%ecx
cmp    $0x8,%ebx
jae    11a4 <rate_matching+0x64>
xor    %edx,%edx
jmp    1290 <rate_matching+0x150>
movzbl 0x4(%rsp),%ecx
lea    0xe7f(%rip),%rdi
mov    %eax,%esi
mov    %ebx,%edx
call   1060 <msg@plt>
mov    $0xffffffff,%eax
jmp    13fa <rate_matching+0x2ba>
cmp    $0x20,%ebx
jae    11b0 <rate_matching+0x70>
xor    %edx,%edx
jmp    1257 <rate_matching+0x117>
mov    %ecx,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1409 <rate_matching+0x2c9>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movaps 0xe23(%rip),%xmm0
nopl   (%rax)
movups (%r14,%rsi,1),%xmm1
movups 0x10(%r14,%rsi,1),%xmm2
movups 0x20(%r14,%rsi,1),%xmm3
movups 0x30(%r14,%rsi,1),%xmm4
orps   %xmm0,%xmm1
orps   %xmm0,%xmm2
movups %xmm1,(%r14,%rsi,1)
movups %xmm2,0x10(%r14,%rsi,1)
orps   %xmm0,%xmm3
orps   %xmm0,%xmm4
movups %xmm3,0x20(%r14,%rsi,1)
movups %xmm4,0x30(%r14,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11e0 <rate_matching+0xa0>
test   $0x1,%bpl
je     124d <rate_matching+0x10d>
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movaps 0xdc4(%rip),%xmm2
orps   %xmm2,%xmm0
orps   %xmm2,%xmm1
movups %xmm0,(%r14,%rsi,1)
movups %xmm1,0x10(%r14,%rsi,1)
cmp    %rcx,%rdx
je     129e <rate_matching+0x15e>
test   $0x18,%cl
je     1290 <rate_matching+0x150>
mov    %rdx,%rsi
mov    %ecx,%edx
and    $0xfffffff8,%edx
movabs $0x8080808080808080,%rdi
80 80 80
nopl   0x0(%rax)
or     %rdi,(%r14,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1270 <rate_matching+0x130>
cmp    %rcx,%rdx
je     129e <rate_matching+0x15e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
orb    $0x80,(%r14,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1290 <rate_matching+0x150>
movzbl 0x4(%rsp),%r15d
xor    %edx,%edx
div    %r15d
mov    %eax,0x8(%rsp)
mov    %r8d,%edi
call   1050 <pset_taus_seed@plt>
mov    %ebx,%eax
xor    %edx,%edx
div    %r15d
mov    %eax,%ebp
mov    %eax,%edi
call   1030 <log2_approx@plt>
lea    0x1(%rax),%ecx
xor    %eax,%eax
mov    $0xffffffff,%r13d
shl    %cl,%r13d
mov    %ebp,%r12d
sub    0x8(%rsp),%r12d
je     13fa <rate_matching+0x2ba>
not    %r13d
mov    %r12d,%eax
neg    %eax
cmovs  %r12d,%eax
mov    %eax,0xc(%rsp)
mov    %r15,0x10(%rsp)
and    $0xfffffffe,%r15d
xor    %eax,%eax
mov    0x4(%rsp),%ebx
jmp    1321 <rate_matching+0x1e1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%eax
add    $0x1,%eax
cmp    0xc(%rsp),%eax
je     13f8 <rate_matching+0x2b8>
mov    %eax,0x8(%rsp)
jmp    133c <rate_matching+0x1fc>
nopw   0x0(%rax,%rax,1)
test   $0x80,%cl
cmove  %ebp,%edx
mov    %edx,%eax
cmp    %ebp,%eax
jb     1360 <rate_matching+0x220>
xor    %eax,%eax
call   1040 <ptaus@plt>
and    %r13d,%eax
cmp    %ebp,%eax
jae    1338 <rate_matching+0x1f8>
movzbl (%r14,%rax,1),%ecx
mov    %ecx,%esi
not    %esi
mov    %ebp,%edx
test   $0xc0,%sil
je     1330 <rate_matching+0x1f0>
mov    %eax,%edx
jmp    1330 <rate_matching+0x1f0>
nop
test   %bl,%bl
je     1310 <rate_matching+0x1d0>
xor    %esi,%esi
cmp    $0x1,%bl
je     13c4 <rate_matching+0x284>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edx
imul   %esi,%edx
add    %eax,%edx
movzbl (%r14,%rdx,1),%ebx
mov    %ebx,%ecx
and    $0x7f,%cl
or     $0xc0,%bl
test   %r12d,%r12d
movzbl %bl,%edi
movzbl %cl,%ecx
cmovs  %edi,%ecx
mov    %cl,(%r14,%rdx,1)
mov    %esi,%ecx
or     $0x1,%ecx
imul   %ebp,%ecx
add    %eax,%ecx
movzbl (%r14,%rcx,1),%edx
mov    %edx,%ebx
and    $0x7f,%bl
or     $0xc0,%dl
test   %r12d,%r12d
movzbl %dl,%edx
movzbl %bl,%edi
cmovs  %edx,%edi
mov    %dil,(%r14,%rcx,1)
add    $0x2,%rsi
cmp    %rsi,%r15
jne    1370 <rate_matching+0x230>
testb  $0x1,0x10(%rsp)
mov    0x4(%rsp),%ebx
je     1310 <rate_matching+0x1d0>
imul   %ebp,%esi
add    %eax,%esi
mov    (%r14,%rsi,1),%al
mov    %eax,%ecx
and    $0x7f,%cl
or     $0xc0,%al
test   %r12d,%r12d
movzbl %al,%eax
movzbl %cl,%ecx
cmovs  %eax,%ecx
mov    %cl,(%r14,%rsi,1)
jmp    1310 <rate_matching+0x1d0>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%bpl
jne    122a <rate_matching+0xea>
jmp    124d <rate_matching+0x10d>

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

LLVM IR (-O2):
@.str = [89 x i8] c"[PHY][CODING] Rate matching parameter error (N_coded %d, N_input %d, N_bps %d), exiting\0A\00"
define i32 @rate_matching(i32 %0, i32 %1, i8* nocapture %2, i8 zeroext %3, i32 %4) {
%6 = mul i32 %0, 9
%7 = shl i32 %1, 2
%8 = icmp ult i32 %6, %7
%9 = lshr i32 %0, 1
%10 = icmp ugt i32 %9, %1
%11 = or i1 %10, %8
br i1 %11, label %90, label %12
12: ; preds = %5
%13 = icmp eq i32 %1, 0
br i1 %13, label %99, label %14
14: ; preds = %12
%15 = zext i32 %1 to i64
%16 = icmp ult i32 %1, 8
br i1 %16, label %88, label %17
17: ; preds = %14
%18 = icmp ult i32 %1, 32
br i1 %18, label %74, label %19
19: ; preds = %17
%20 = and i64 %15, 4294967264
%21 = add nsw i64 %20, -32
%22 = lshr exact i64 %21, 5
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 1
%25 = icmp eq i64 %21, 0
br i1 %25, label %55, label %26
26: ; preds = %19
%27 = and i64 %23, 1152921504606846974
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ 0, %26 ], [ %52, %28 ]
%30 = phi i64 [ 0, %26 ], [ %53, %28 ]
%31 = getelementptr inbounds i8, i8* %2, i64 %29
%32 = bitcast i8* %31 to <16 x i8>*
%33 = load <16 x i8>, <16 x i8>* %32
%34 = getelementptr inbounds i8, i8* %31, i64 16
%35 = bitcast i8* %34 to <16 x i8>*
%36 = load <16 x i8>, <16 x i8>* %35
%37 = or <16 x i8> %33, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%38 = or <16 x i8> %36, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%39 = bitcast i8* %31 to <16 x i8>*
store <16 x i8> %37, <16 x i8>* %39
%40 = bitcast i8* %34 to <16 x i8>*
store <16 x i8> %38, <16 x i8>* %40
%41 = or i64 %29, 32
%42 = getelementptr inbounds i8, i8* %2, i64 %41
%43 = bitcast i8* %42 to <16 x i8>*
%44 = load <16 x i8>, <16 x i8>* %43
%45 = getelementptr inbounds i8, i8* %42, i64 16
%46 = bitcast i8* %45 to <16 x i8>*
%47 = load <16 x i8>, <16 x i8>* %46
%48 = or <16 x i8> %44, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%49 = or <16 x i8> %47, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%50 = bitcast i8* %42 to <16 x i8>*
store <16 x i8> %48, <16 x i8>* %50
%51 = bitcast i8* %45 to <16 x i8>*
store <16 x i8> %49, <16 x i8>* %51
%52 = add nuw i64 %29, 64
%53 = add i64 %30, 2
%54 = icmp eq i64 %53, %27
br i1 %54, label %55, label %28
55: ; preds = %28, %19
%56 = phi i64 [ 0, %19 ], [ %52, %28 ]
%57 = icmp eq i64 %24, 0
br i1 %57, label %69, label %58
58: ; preds = %55
%59 = getelementptr inbounds i8, i8* %2, i64 %56
%60 = bitcast i8* %59 to <16 x i8>*
%61 = load <16 x i8>, <16 x i8>* %60
%62 = getelementptr inbounds i8, i8* %59, i64 16
%63 = bitcast i8* %62 to <16 x i8>*
%64 = load <16 x i8>, <16 x i8>* %63
%65 = or <16 x i8> %61, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%66 = or <16 x i8> %64, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%67 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %65, <16 x i8>* %67
%68 = bitcast i8* %62 to <16 x i8>*
store <16 x i8> %66, <16 x i8>* %68
br label %69
69: ; preds = %55, %58
%70 = icmp eq i64 %20, %15
br i1 %70, label %99, label %71
71: ; preds = %69
%72 = and i64 %15, 24
%73 = icmp eq i64 %72, 0
br i1 %73, label %88, label %74
74: ; preds = %17, %71
%75 = phi i64 [ %20, %71 ], [ 0, %17 ]
%76 = and i64 %15, 4294967288
br label %77
77: ; preds = %77, %74
%78 = phi i64 [ %75, %74 ], [ %84, %77 ]
%79 = getelementptr inbounds i8, i8* %2, i64 %78
%80 = bitcast i8* %79 to <8 x i8>*
%81 = load <8 x i8>, <8 x i8>* %80
%82 = or <8 x i8> %81, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%83 = bitcast i8* %79 to <8 x i8>*
store <8 x i8> %82, <8 x i8>* %83
%84 = add nuw i64 %78, 8
%85 = icmp eq i64 %84, %76
br i1 %85, label %86, label %77
86: ; preds = %77
%87 = icmp eq i64 %76, %15
br i1 %87, label %99, label %88
88: ; preds = %14, %71, %86
%89 = phi i64 [ 0, %14 ], [ %20, %71 ], [ %76, %86 ]
br label %92
90: ; preds = %5
%91 = tail call i32 @msg(i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str, i64 0, i64 0), i32 %0, i32 %1, i8 zeroext %3)
br label %180
92: ; preds = %88, %92
%93 = phi i64 [ %97, %92 ], [ %89, %88 ]
%94 = getelementptr inbounds i8, i8* %2, i64 %93
%95 = load i8, i8* %94
%96 = or i8 %95, -128
store i8 %96, i8* %94
%97 = add nuw nsw i64 %93, 1
%98 = icmp eq i64 %97, %15
br i1 %98, label %99, label %92
99: ; preds = %92, %69, %86, %12
%100 = zext i8 %3 to i32
%101 = udiv i32 %0, %100
%102 = tail call i32 @pset_taus_seed(i32 %4)
%103 = udiv i32 %1, %100
%104 = sub i32 %103, %101
%105 = icmp slt i32 %104, 0
%106 = tail call i32 @log2_approx(i32 %103)
%107 = add nsw i32 %106, 1
%108 = shl nsw i32 -1, %107
%109 = xor i32 %108, -1
%110 = icmp eq i32 %104, 0
br i1 %110, label %180, label %111
111: ; preds = %99
%112 = sub nsw i32 0, %104
%113 = select i1 %105, i32 %112, i32 %104
%114 = zext i8 %3 to i64
%115 = and i64 %114, 1
%116 = icmp eq i8 %3, 1
%117 = and i64 %114, 254
%118 = icmp eq i64 %115, 0
br label %119
119: ; preds = %111, %177
%120 = phi i32 [ 0, %111 ], [ %178, %177 ]
br label %121
121: ; preds = %119, %136
%122 = tail call i32 (...) @ptaus()
%123 = and i32 %122, %109
%124 = icmp ult i32 %123, %103
br i1 %124, label %125, label %136
125: ; preds = %121
%126 = zext i32 %123 to i64
%127 = getelementptr inbounds i8, i8* %2, i64 %126
%128 = load i8, i8* %127
%129 = zext i8 %128 to i32
%130 = and i32 %129, 128
%131 = icmp eq i32 %130, 0
%132 = and i32 %129, 192
%133 = icmp eq i32 %132, 192
%134 = or i1 %131, %133
%135 = select i1 %134, i32 %103, i32 %123
br label %136
136: ; preds = %125, %121
%137 = phi i32 [ %123, %121 ], [ %135, %125 ]
%138 = icmp ult i32 %137, %103
br i1 %138, label %139, label %121
139: ; preds = %136
switch i8 %3, label %140 [
i8 0, label %177
i8 1, label %165
]
140: ; preds = %139, %140
%141 = phi i64 [ %162, %140 ], [ 0, %139 ]
%142 = phi i64 [ %163, %140 ], [ 0, %139 ]
%143 = trunc i64 %141 to i32
%144 = mul i32 %103, %143
%145 = add i32 %144, %137
%146 = zext i32 %145 to i64
%147 = getelementptr inbounds i8, i8* %2, i64 %146
%148 = load i8, i8* %147
%149 = and i8 %148, 127
%150 = or i8 %148, -64
%151 = select i1 %105, i8 %150, i8 %149
store i8 %151, i8* %147
%152 = trunc i64 %141 to i32
%153 = or i32 %152, 1
%154 = mul i32 %103, %153
%155 = add i32 %154, %137
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %2, i64 %156
%158 = load i8, i8* %157
%159 = and i8 %158, 127
%160 = or i8 %158, -64
%161 = select i1 %105, i8 %160, i8 %159
store i8 %161, i8* %157
%162 = add nuw nsw i64 %141, 2
%163 = add i64 %142, 2
%164 = icmp eq i64 %163, %117
br i1 %164, label %165, label %140
165: ; preds = %140, %139
%166 = phi i64 [ 0, %139 ], [ %162, %140 ]
br i1 %118, label %177, label %167
167: ; preds = %165
%168 = trunc i64 %166 to i32
%169 = mul i32 %103, %168
%170 = add i32 %169, %137
%171 = zext i32 %170 to i64
%172 = getelementptr inbounds i8, i8* %2, i64 %171
%173 = load i8, i8* %172
%174 = and i8 %173, 127
%175 = or i8 %173, -64
%176 = select i1 %105, i8 %175, i8 %174
store i8 %176, i8* %172
br label %177
177: ; preds = %167, %165, %139
%178 = add nuw nsw i32 %120, 1
%179 = icmp eq i32 %178, %113
br i1 %179, label %180, label %119
180: ; preds = %177, %99, %90
%181 = phi i32 [ -1, %90 ], [ 0, %99 ], [ 0, %177 ]
ret i32 %181
}