#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 uint16_t;
typedef int int64_t;

/* Variables and functions */
void tri_to_string(const uint16_t in_len, const int64_t *poly,
                   unsigned char *str) {
  unsigned char tmp1, tmp2;
  int i, j;
  int padNover5;
  padNover5 = in_len / 5;
  if (in_len % 5 == 0)
    padNover5--;
  for (i = 0; i < padNover5; i++) {
    tmp1 = 0;
    for (j = 0; j < 5; j++) {
      tmp2 = (poly[i * 5 + j] & 0b11);
      if (tmp2 == 0b11)
        tmp2 = 2;
      tmp1 += tmp2;
      if (j != 4)
        tmp1 *= 3;
    }
    str[i] = tmp1;
  }
  tmp1 = 0;
  for (i = 0; i < 5; i++) {
    if (padNover5 * 5 + i > in_len && i != 4)
      tmp1 *= 3;
    else {
      tmp2 = (poly[padNover5 * 5 + i] & 0b11);
      if (tmp2 == 0b11)
        tmp2 = 2;
      tmp1 += tmp2;
      if (i != 4)
        tmp1 *= 3;
    }
  }
  str[padNover5] = tmp1;
  return;
}


x86 assembly (clang, -O0):
<tri_to_string>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    113a <tri_to_string+0x3a>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11da <tri_to_string+0xda>
movb   $0x0,-0x19(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x5,-0x24(%rbp)
jge    11be <tri_to_string+0xbe>
mov    -0x10(%rbp),%rax
imul   $0x5,-0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0x3,%eax
mov    %al,-0x1a(%rbp)
movzbl -0x1a(%rbp),%eax
cmp    $0x3,%eax
jne    118a <tri_to_string+0x8a>
movb   $0x2,-0x1a(%rbp)
movzbl -0x1a(%rbp),%ecx
movzbl -0x19(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x19(%rbp)
cmpl   $0x4,-0x24(%rbp)
je     11ab <tri_to_string+0xab>
movzbl -0x19(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %al,-0x19(%rbp)
jmp    11b0 <tri_to_string+0xb0>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1158 <tri_to_string+0x58>
mov    -0x19(%rbp),%dl
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1141 <tri_to_string+0x41>
movb   $0x0,-0x19(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x5,-0x20(%rbp)
jge    1279 <tri_to_string+0x179>
imul   $0x5,-0x28(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1218 <tri_to_string+0x118>
cmpl   $0x4,-0x20(%rbp)
je     1218 <tri_to_string+0x118>
movzbl -0x19(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %al,-0x19(%rbp)
jmp    1266 <tri_to_string+0x166>
mov    -0x10(%rbp),%rax
imul   $0x5,-0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0x3,%eax
mov    %al,-0x1a(%rbp)
movzbl -0x1a(%rbp),%eax
cmp    $0x3,%eax
jne    1240 <tri_to_string+0x140>
movb   $0x2,-0x1a(%rbp)
movzbl -0x1a(%rbp),%ecx
movzbl -0x19(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x19(%rbp)
cmpl   $0x4,-0x20(%rbp)
je     1261 <tri_to_string+0x161>
movzbl -0x19(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %al,-0x19(%rbp)
jmp    1266 <tri_to_string+0x166>
jmp    126b <tri_to_string+0x16b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11e5 <tri_to_string+0xe5>
mov    -0x19(%rbp),%dl
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<tri_to_string>:
push   %rbp
push   %r14
push   %rbx
movslq %edi,%r8
imul   $0x66666667,%r8,%r9
mov    %r9,%rax
shr    $0x3f,%rax
sar    $0x21,%r9
add    %eax,%r9d
imul   $0xcccccccd,%r8d,%eax
add    $0x19999999,%eax
cmp    $0x33333333,%eax
sbb    $0x0,%r9d
test   %r9d,%r9d
jle    1215 <tri_to_string+0x115>
mov    %r9d,%r10d
cmp    $0x4,%r9d
jb     1161 <tri_to_string+0x61>
lea    (%r10,%r10,4),%rax
lea    (%rsi,%rax,4),%rax
cmp    %rdx,%rax
jbe    12da <tri_to_string+0x1da>
lea    (%rdx,%r10,1),%rax
cmp    %rsi,%rax
jbe    12da <tri_to_string+0x1da>
xor    %ebp,%ebp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsi,%rax,4),%rax
add    $0x10,%rax
mov    $0x6,%r11d
mov    $0x2,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0x10(%rax),%ebx
movzbl -0xc(%rax),%ecx
and    $0x3,%bl
movzbl %bl,%ebx
cmp    $0x3,%bl
lea    (%rbx,%rbx,2),%ebx
cmove  %r11d,%ebx
and    $0x3,%cl
cmp    $0x3,%cl
movzbl %cl,%ecx
cmove  %r14d,%ecx
add    %bl,%cl
movzbl %cl,%ecx
movzbl -0x8(%rax),%ebx
and    $0x3,%bl
cmp    $0x3,%bl
movzbl %bl,%ebx
cmove  %r14d,%ebx
lea    (%rcx,%rcx,2),%ecx
add    %cl,%bl
movzbl %bl,%ecx
lea    (%rcx,%rcx,2),%ecx
movzbl -0x4(%rax),%ebx
and    $0x3,%bl
cmp    $0x3,%bl
movzbl %bl,%ebx
cmove  %r14d,%ebx
add    %cl,%bl
movzbl %bl,%ecx
lea    (%rcx,%rcx,2),%ecx
movzbl (%rax),%ebx
and    $0x3,%bl
cmp    $0x3,%bl
movzbl %bl,%ebx
cmove  %r14d,%ebx
add    %cl,%bl
mov    %bl,(%rdx,%rbp,1)
add    $0x1,%rbp
add    $0x14,%rax
cmp    %rbp,%r10
jne    1190 <tri_to_string+0x90>
lea    (%r9,%r9,4),%ebx
movslq %ebx,%rax
cmp    %edi,%eax
jle    1228 <tri_to_string+0x128>
xor    %ebp,%ebp
cmp    %edi,%ebx
jl     1243 <tri_to_string+0x143>
jmp    125d <tri_to_string+0x15d>
mov    (%rsi,%rax,4),%cl
and    $0x3,%cl
movzbl %cl,%ecx
cmp    $0x3,%cl
lea    (%rcx,%rcx,2),%ecx
mov    $0x6,%ebp
cmovne %ecx,%ebp
cmp    %edi,%ebx
jge    125d <tri_to_string+0x15d>
mov    0x4(%rsi,%rax,4),%bl
and    $0x3,%bl
cmp    $0x3,%bl
movzbl %bl,%edi
mov    $0x2,%ecx
cmovne %edi,%ecx
add    %bpl,%cl
mov    %ecx,%ebp
movzbl %bpl,%ecx
lea    (%rcx,%rcx,2),%ebp
lea    0x2(%rax),%rdi
cmp    %r8,%rdi
jg     1287 <tri_to_string+0x187>
mov    0x8(%rsi,%rax,4),%bl
and    $0x3,%bl
cmp    $0x3,%bl
movzbl %bl,%edi
mov    $0x2,%ecx
cmovne %edi,%ecx
add    %bpl,%cl
mov    %ecx,%ebp
movzbl %bpl,%ecx
lea    (%rcx,%rcx,2),%ebp
lea    0x3(%rax),%rdi
cmp    %r8,%rdi
jg     12b1 <tri_to_string+0x1b1>
mov    0xc(%rsi,%rax,4),%bl
and    $0x3,%bl
cmp    $0x3,%bl
movzbl %bl,%edi
mov    $0x2,%ecx
cmovne %edi,%ecx
add    %bpl,%cl
mov    %ecx,%ebp
movzbl %bpl,%ecx
mov    0x10(%rsi,%rax,4),%al
and    $0x3,%al
cmp    $0x3,%al
movzbl %al,%eax
mov    $0x2,%esi
cmovne %eax,%esi
lea    (%rcx,%rcx,2),%eax
add    %al,%sil
movslq %r9d,%rax
mov    %sil,(%rdx,%rax,1)
pop    %rbx
pop    %r14
pop    %rbp
ret
mov    %r10d,%ebp
and    $0xfffffffc,%ebp
xor    %r11d,%r11d
movdqa 0xd14(%rip),%xmm13
movdqa 0xd1b(%rip),%xmm9
movdqa 0xd22(%rip),%xmm12
movdqa 0xd29(%rip),%xmm8
movdqa 0xd30(%rip),%xmm11
movdqa 0xd37(%rip),%xmm10
mov    %rsi,%rax
nopl   0x0(%rax)
movupd 0x40(%rax),%xmm14
movdqu (%rax),%xmm7
movdqu 0x10(%rax),%xmm2
movdqu 0x20(%rax),%xmm5
movdqu 0x30(%rax),%xmm15
pshufd $0x55,%xmm2,%xmm0
movdqa %xmm7,%xmm3
punpcklbw %xmm0,%xmm3
pand   %xmm13,%xmm3
pshufd $0xaa,%xmm5,%xmm0
punpckhdq %xmm15,%xmm0
pand   %xmm9,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movdqa %xmm13,%xmm4
pandn  %xmm0,%xmm4
por    %xmm3,%xmm4
pand   %xmm12,%xmm4
movdqa %xmm4,%xmm0
paddb  %xmm4,%xmm0
paddb  %xmm4,%xmm0
pcmpeqb %xmm12,%xmm4
movdqa %xmm4,%xmm3
pandn  %xmm0,%xmm3
pand   %xmm8,%xmm4
por    %xmm3,%xmm4
movdqa %xmm2,%xmm6
movsd  %xmm7,%xmm6
pshufd $0xaa,%xmm7,%xmm0
movsd  %xmm5,%xmm7
pshufd $0x55,%xmm5,%xmm3
movsd  %xmm14,%xmm5
shufps $0xec,%xmm5,%xmm5
pshuflw $0x24,%xmm5,%xmm5
pand   %xmm11,%xmm5
packuswb %xmm5,%xmm5
movdqa %xmm13,%xmm1
pandn  %xmm5,%xmm1
shufps $0xe6,%xmm6,%xmm6
pshuflw $0xe2,%xmm6,%xmm5
pand   %xmm11,%xmm5
packuswb %xmm5,%xmm5
pand   %xmm13,%xmm5
por    %xmm1,%xmm5
pand   %xmm12,%xmm5
movdqa %xmm5,%xmm1
pcmpeqb %xmm12,%xmm1
movdqa %xmm1,%xmm6
pandn  %xmm5,%xmm6
pand   %xmm10,%xmm1
por    %xmm6,%xmm1
paddb  %xmm4,%xmm1
pshufd $0x55,%xmm14,%xmm4
pshufd $0xaa,%xmm15,%xmm5
punpckhdq %xmm14,%xmm5
movsd  %xmm15,%xmm14
punpckldq %xmm4,%xmm15
pshuflw $0x84,%xmm15,%xmm4
pand   %xmm11,%xmm4
packuswb %xmm4,%xmm4
movdqa %xmm13,%xmm6
pandn  %xmm4,%xmm6
punpckhdq %xmm2,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pand   %xmm11,%xmm0
pshufd $0xaa,%xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm13,%xmm0
por    %xmm6,%xmm0
pand   %xmm12,%xmm0
movdqa %xmm0,%xmm4
pcmpeqb %xmm12,%xmm4
movdqa %xmm4,%xmm6
pandn  %xmm0,%xmm6
pand   %xmm10,%xmm4
por    %xmm6,%xmm4
paddb  %xmm1,%xmm4
paddb  %xmm1,%xmm1
paddb  %xmm1,%xmm4
shufps $0xe6,%xmm14,%xmm14
pshuflw $0x24,%xmm14,%xmm0
pand   %xmm11,%xmm0
packuswb %xmm0,%xmm0
movdqa %xmm13,%xmm1
pandn  %xmm0,%xmm1
shufps $0xec,%xmm7,%xmm7
pshuflw $0xe2,%xmm7,%xmm0
pand   %xmm11,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm13,%xmm0
por    %xmm1,%xmm0
pand   %xmm12,%xmm0
movdqa %xmm0,%xmm1
pcmpeqb %xmm12,%xmm1
movdqa %xmm1,%xmm6
pandn  %xmm0,%xmm6
pand   %xmm10,%xmm1
por    %xmm6,%xmm1
paddb  %xmm4,%xmm1
paddb  %xmm4,%xmm4
paddb  %xmm4,%xmm1
punpcklbw %xmm3,%xmm2
pand   %xmm13,%xmm2
pand   %xmm9,%xmm5
packuswb %xmm5,%xmm5
packuswb %xmm5,%xmm5
movdqa %xmm13,%xmm0
pandn  %xmm5,%xmm0
por    %xmm2,%xmm0
pand   %xmm12,%xmm0
movdqa %xmm0,%xmm2
pcmpeqb %xmm12,%xmm2
movdqa %xmm2,%xmm3
pandn  %xmm0,%xmm3
pand   %xmm10,%xmm2
por    %xmm3,%xmm2
paddb  %xmm1,%xmm2
paddb  %xmm1,%xmm1
paddb  %xmm1,%xmm2
movd   %xmm2,(%rdx,%r11,1)
add    $0x4,%r11
add    $0x50,%rax
cmp    %r11,%rbp
jne    1320 <tri_to_string+0x220>
cmp    %r10,%rbp
je     1215 <tri_to_string+0x115>
jmp    1163 <tri_to_string+0x63>

LLVM IR (-O0):
define void @tri_to_string(i32 %0, i32* %1, i8* %2) {
%4 = alloca i32
%5 = alloca i32*
%6 = alloca i8*
%7 = alloca i8
%8 = alloca i8
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store i32 %0, i32* %4
store i32* %1, i32** %5
store i8* %2, i8** %6
%12 = load i32, i32* %4
%13 = sdiv i32 %12, 5
store i32 %13, i32* %11
%14 = load i32, i32* %4
%15 = srem i32 %14, 5
%16 = icmp eq i32 %15, 0
br i1 %16, label %17, label %20
17: ; preds = %3
%18 = load i32, i32* %11
%19 = add nsw i32 %18, -1
store i32 %19, i32* %11
br label %20
20: ; preds = %17, %3
store i32 0, i32* %9
br label %21
21: ; preds = %68, %20
%22 = load i32, i32* %9
%23 = load i32, i32* %11
%24 = icmp slt i32 %22, %23
br i1 %24, label %25, label %71
25: ; preds = %21
store i8 0, i8* %7
store i32 0, i32* %10
br label %26
26: ; preds = %59, %25
%27 = load i32, i32* %10
%28 = icmp slt i32 %27, 5
br i1 %28, label %29, label %62
29: ; preds = %26
%30 = load i32*, i32** %5
%31 = load i32, i32* %9
%32 = mul nsw i32 %31, 5
%33 = load i32, i32* %10
%34 = add nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i32, i32* %30, i64 %35
%37 = load i32, i32* %36
%38 = and i32 %37, 3
%39 = trunc i32 %38 to i8
store i8 %39, i8* %8
%40 = load i8, i8* %8
%41 = zext i8 %40 to i32
%42 = icmp eq i32 %41, 3
br i1 %42, label %43, label %44
43: ; preds = %29
store i8 2, i8* %8
br label %44
44: ; preds = %43, %29
%45 = load i8, i8* %8
%46 = zext i8 %45 to i32
%47 = load i8, i8* %7
%48 = zext i8 %47 to i32
%49 = add nsw i32 %48, %46
%50 = trunc i32 %49 to i8
store i8 %50, i8* %7
%51 = load i32, i32* %10
%52 = icmp ne i32 %51, 4
br i1 %52, label %53, label %58
53: ; preds = %44
%54 = load i8, i8* %7
%55 = zext i8 %54 to i32
%56 = mul nsw i32 %55, 3
%57 = trunc i32 %56 to i8
store i8 %57, i8* %7
br label %58
58: ; preds = %53, %44
br label %59
59: ; preds = %58
%60 = load i32, i32* %10
%61 = add nsw i32 %60, 1
store i32 %61, i32* %10
br label %26
62: ; preds = %26
%63 = load i8, i8* %7
%64 = load i8*, i8** %6
%65 = load i32, i32* %9
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i8, i8* %64, i64 %66
store i8 %63, i8* %67
br label %68
68: ; preds = %62
%69 = load i32, i32* %9
%70 = add nsw i32 %69, 1
store i32 %70, i32* %9
br label %21
71: ; preds = %21
store i8 0, i8* %7
store i32 0, i32* %9
br label %72
72: ; preds = %121, %71
%73 = load i32, i32* %9
%74 = icmp slt i32 %73, 5
br i1 %74, label %75, label %124
75: ; preds = %72
%76 = load i32, i32* %11
%77 = mul nsw i32 %76, 5
%78 = load i32, i32* %9
%79 = add nsw i32 %77, %78
%80 = load i32, i32* %4
%81 = icmp sgt i32 %79, %80
br i1 %81, label %82, label %90
82: ; preds = %75
%83 = load i32, i32* %9
%84 = icmp ne i32 %83, 4
br i1 %84, label %85, label %90
85: ; preds = %82
%86 = load i8, i8* %7
%87 = zext i8 %86 to i32
%88 = mul nsw i32 %87, 3
%89 = trunc i32 %88 to i8
store i8 %89, i8* %7
br label %120
90: ; preds = %82, %75
%91 = load i32*, i32** %5
%92 = load i32, i32* %11
%93 = mul nsw i32 %92, 5
%94 = load i32, i32* %9
%95 = add nsw i32 %93, %94
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32, i32* %91, i64 %96
%98 = load i32, i32* %97
%99 = and i32 %98, 3
%100 = trunc i32 %99 to i8
store i8 %100, i8* %8
%101 = load i8, i8* %8
%102 = zext i8 %101 to i32
%103 = icmp eq i32 %102, 3
br i1 %103, label %104, label %105
104: ; preds = %90
store i8 2, i8* %8
br label %105
105: ; preds = %104, %90
%106 = load i8, i8* %8
%107 = zext i8 %106 to i32
%108 = load i8, i8* %7
%109 = zext i8 %108 to i32
%110 = add nsw i32 %109, %107
%111 = trunc i32 %110 to i8
store i8 %111, i8* %7
%112 = load i32, i32* %9
%113 = icmp ne i32 %112, 4
br i1 %113, label %114, label %119
114: ; preds = %105
%115 = load i8, i8* %7
%116 = zext i8 %115 to i32
%117 = mul nsw i32 %116, 3
%118 = trunc i32 %117 to i8
store i8 %118, i8* %7
br label %119
119: ; preds = %114, %105
br label %120
120: ; preds = %119, %85
br label %121
121: ; preds = %120
%122 = load i32, i32* %9
%123 = add nsw i32 %122, 1
store i32 %123, i32* %9
br label %72
124: ; preds = %72
%125 = load i8, i8* %7
%126 = load i8*, i8** %6
%127 = load i32, i32* %11
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %126, i64 %128
store i8 %125, i8* %129
ret void
}

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