#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 __WORDSIZE;
int /*<<< orphan*/ assert(int);
size_t strlen(char *);
int main() {
  char buf[(__WORDSIZE / 8 * 4) + 1 + __WORDSIZE / 8];
  size_t len;
  assert(strlen("") == 0);
  for (len = 0; len < (__WORDSIZE / 8 * 4); ++len) {
    unsigned int mask;
    buf[len] = len % 10 + '0';
    buf[len + 1] = '\0';
    for (mask = 0; mask < (1u << __WORDSIZE / 8); ++mask) {
      size_t bit;
      size_t i;
      for (bit = 0; bit < __WORDSIZE / 8; ++bit)
        buf[len + 2 + bit] = (mask & (1u << bit)) ? 0xff : 0;
      for (i = 0; i <= len; ++i)
        assert(strlen(buf + i) == len + 1 - i);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
mov    0x2eb2(%rip),%rax
mov    (%rax),%ecx
mov    %ecx,%eax
add    $0x7,%eax
test   %ecx,%ecx
cmovs  %eax,%ecx
sar    $0x3,%ecx
mov    %ecx,%eax
lea    0x1(%rax,%rax,4),%eax
mov    %rsp,%rcx
mov    %rcx,-0x10(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x18(%rbp)
lea    0xe8b(%rip),%rdi
call   1030 <strlen@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    0x2e46(%rip),%rax
mov    (%rax),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
shl    $0x2,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jae    130c <main+0x1ec>
mov    -0x20(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    -0x40(%rbp),%rax
add    $0x30,%rdx
mov    -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rcx
movb   $0x0,0x1(%rax,%rcx,1)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    0x2ded(%rip),%rax
mov    (%rax),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4c(%rbp),%eax
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
cmp    %ecx,%eax
jae    12f6 <main+0x1d6>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    0x2db6(%rip),%rax
mov    (%rax),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
cmp    %rcx,%rax
jae    1293 <main+0x173>
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%esi
mov    -0x30(%rbp),%rcx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%esi
xor    %ecx,%ecx
mov    $0xff,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
mov    %cl,%dl
mov    -0x20(%rbp),%rcx
add    $0x2,%rcx
add    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1223 <main+0x103>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
ja     12e3 <main+0x1c3>
mov    -0x40(%rbp),%rdi
add    -0x38(%rbp),%rdi
call   1030 <strlen@plt>
mov    -0x20(%rbp),%rcx
add    $0x1,%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    129b <main+0x17b>
jmp    12e8 <main+0x1c8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ee <main+0xce>
jmp    12fb <main+0x1db>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1193 <main+0x73>
movl   $0x0,-0x4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    0x2eb0(%rip),%rbx
mov    (%rbx),%eax
lea    0x7(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
sar    $0x3,%ecx
lea    (%rcx,%rcx,4),%eax
add    $0x1,%eax
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rcx,%rsp
mov    $0x1,%edi
call   1040 <assert@plt>
mov    (%rbx),%esi
lea    0x7(%rsi),%eax
cmp    $0xf,%eax
jae    1185 <main+0x65>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    -0x30(%rbp),%rax
lea    0x12(%rax),%r13
lea    0x2(%rax),%r14
mov    $0x1,%eax
mov    %rax,-0x38(%rbp)
xor    %edi,%edi
movdqa 0xe9b(%rip),%xmm11
movdqa 0xea2(%rip),%xmm12
pxor   %xmm13,%xmm13
pcmpeqd %xmm14,%xmm14
movdqa 0xe9f(%rip),%xmm15
jmp    11ec <main+0xcc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
shl    $0x2,%ecx
movslq %ecx,%rax
addq   $0x1,-0x38(%rbp)
add    $0x1,%r13
add    $0x1,%r14
mov    -0x40(%rbp),%rdi
cmp    %rax,%rdi
jae    1174 <main+0x54>
mov    %rdi,%rax
movabs $0xcccccccccccccccd,%rcx
cc cc cc
mul    %rcx
shr    $0x2,%edx
and    $0xfffffffe,%edx
lea    (%rdx,%rdx,4),%eax
mov    %edi,%ecx
sub    %eax,%ecx
or     $0x30,%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax,%rdi,1)
lea    0x1(%rdi),%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x0,0x1(%rax,%rdi,1)
lea    0x7(%rsi),%eax
test   %esi,%esi
cmovns %esi,%eax
sar    $0x3,%eax
add    $0x2,%rdi
mov    %rdi,-0x48(%rbp)
movd   %eax,%xmm0
pshufd $0x51,%xmm0,%xmm0
nopl   0x0(%rax)
pshufd $0x55,%xmm0,%xmm1
movd   %xmm1,%ecx
movd   %xmm0,%r15d
test   %ecx,%ecx
je     1643 <main+0x523>
movslq %ecx,%rax
cmp    $0x10,%ecx
jae    1270 <main+0x150>
xor    %ecx,%ecx
jmp    1630 <main+0x510>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rcx
and    $0xfffffffffffffff0,%rcx
pshufd $0x0,%xmm0,%xmm8
lea    -0x10(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     16cb <main+0x5ab>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movdqa 0xd8a(%rip),%xmm4
movdqa 0xd72(%rip),%xmm3
movdqa 0xd59(%rip),%xmm10
movdqa 0xd40(%rip),%xmm9
movdqa %xmm4,%xmm0
pslld  $0x17,%xmm0
paddd  %xmm11,%xmm0
cvttps2dq %xmm0,%xmm0
pshufd $0xf5,%xmm0,%xmm6
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm5
pmuludq %xmm12,%xmm6
pshufd $0xe8,%xmm6,%xmm0
punpckldq %xmm0,%xmm5
movdqa %xmm3,%xmm0
pslld  $0x17,%xmm0
paddd  %xmm11,%xmm0
cvttps2dq %xmm0,%xmm0
pshufd $0xf5,%xmm0,%xmm7
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm6
pmuludq %xmm12,%xmm7
pshufd $0xe8,%xmm7,%xmm0
punpckldq %xmm0,%xmm6
movdqa %xmm10,%xmm0
pslld  $0x17,%xmm0
paddd  %xmm11,%xmm0
cvttps2dq %xmm0,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm7
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm7
movdqa %xmm9,%xmm0
pslld  $0x17,%xmm0
paddd  %xmm11,%xmm0
cvttps2dq %xmm0,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pand   %xmm8,%xmm0
pand   %xmm8,%xmm7
pand   %xmm8,%xmm6
pand   %xmm8,%xmm5
pcmpeqd %xmm13,%xmm5
pxor   %xmm14,%xmm5
pcmpeqd %xmm13,%xmm6
pxor   %xmm14,%xmm6
packssdw %xmm6,%xmm5
pcmpeqd %xmm13,%xmm7
pxor   %xmm14,%xmm7
pcmpeqd %xmm13,%xmm0
pxor   %xmm14,%xmm0
packssdw %xmm0,%xmm7
packsswb %xmm7,%xmm5
movdqu %xmm5,-0x10(%r13,%rdx,1)
movdqa %xmm9,%xmm6
paddd  %xmm15,%xmm6
movdqa %xmm10,%xmm0
paddd  %xmm15,%xmm0
movdqa %xmm3,%xmm1
paddd  %xmm15,%xmm1
movdqa %xmm4,%xmm5
paddd  %xmm15,%xmm5
pslld  $0x17,%xmm5
paddd  %xmm11,%xmm5
cvttps2dq %xmm5,%xmm5
pshufd $0xf5,%xmm5,%xmm7
pmuludq %xmm12,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pmuludq %xmm12,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm5
pslld  $0x17,%xmm1
paddd  %xmm11,%xmm1
cvttps2dq %xmm1,%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm7
pmuludq %xmm12,%xmm2
pshufd $0xe8,%xmm2,%xmm1
punpckldq %xmm1,%xmm7
pslld  $0x17,%xmm0
paddd  %xmm11,%xmm0
cvttps2dq %xmm0,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pslld  $0x17,%xmm6
paddd  %xmm11,%xmm6
cvttps2dq %xmm6,%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm6
pmuludq %xmm12,%xmm2
pshufd $0xe8,%xmm2,%xmm1
punpckldq %xmm1,%xmm6
pand   %xmm8,%xmm6
pand   %xmm8,%xmm0
pand   %xmm8,%xmm7
pand   %xmm8,%xmm5
pcmpeqd %xmm13,%xmm5
pxor   %xmm14,%xmm5
pcmpeqd %xmm13,%xmm7
pxor   %xmm14,%xmm7
packssdw %xmm7,%xmm5
pcmpeqd %xmm13,%xmm0
pxor   %xmm14,%xmm0
pcmpeqd %xmm13,%xmm6
pxor   %xmm14,%xmm6
packssdw %xmm6,%xmm0
packsswb %xmm0,%xmm5
movdqu %xmm5,0x0(%r13,%rdx,1)
movdqa 0xb7a(%rip),%xmm0
add    $0x20,%rdx
paddd  %xmm0,%xmm4
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm10
paddd  %xmm0,%xmm9
add    $0xfffffffffffffffe,%rdi
jne    12c0 <main+0x1a0>
test   $0x1,%sil
je     1625 <main+0x505>
pslld  $0x17,%xmm4
paddd  %xmm11,%xmm4
cvttps2dq %xmm4,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm4
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm4
pslld  $0x17,%xmm3
paddd  %xmm11,%xmm3
cvttps2dq %xmm3,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm3
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm3
pslld  $0x17,%xmm10
paddd  %xmm11,%xmm10
cvttps2dq %xmm10,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pslld  $0x17,%xmm9
paddd  %xmm11,%xmm9
cvttps2dq %xmm9,%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm12,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
pand   %xmm8,%xmm1
pand   %xmm8,%xmm0
pand   %xmm8,%xmm3
pand   %xmm8,%xmm4
pcmpeqd %xmm13,%xmm4
pxor   %xmm14,%xmm4
pcmpeqd %xmm13,%xmm3
pxor   %xmm14,%xmm3
packssdw %xmm3,%xmm4
pcmpeqd %xmm13,%xmm0
pxor   %xmm14,%xmm0
pcmpeqd %xmm13,%xmm1
pxor   %xmm14,%xmm1
packssdw %xmm1,%xmm0
packsswb %xmm0,%xmm4
add    -0x48(%rbp),%rdx
mov    -0x30(%rbp),%rsi
movdqu %xmm4,(%rsi,%rdx,1)
cmp    %rax,%rcx
je     1643 <main+0x523>
nopw   0x0(%rax,%rax,1)
bt     %ecx,%r15d
sbb    %edx,%edx
mov    %dl,(%r14,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1630 <main+0x510>
mov    -0x30(%rbp),%rbx
mov    -0x38(%rbp),%r12
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
call   1030 <strlen@plt>
xor    %edi,%edi
cmp    %rax,%r12
sete   %dil
call   1040 <assert@plt>
add    $0x1,%rbx
add    $0xffffffffffffffff,%r12
jne    1650 <main+0x530>
add    $0x1,%r15d
mov    0x296d(%rip),%rax
mov    (%rax),%esi
lea    0x7(%rsi),%ecx
test   %esi,%esi
cmovns %esi,%ecx
sar    $0x3,%ecx
movd   %r15d,%xmm0
shr    %cl,%r15d
movd   %ecx,%xmm1
punpckldq %xmm1,%xmm0
test   %r15d,%r15d
movdqa 0x99c(%rip),%xmm11
movdqa 0x9a3(%rip),%xmm12
pxor   %xmm13,%xmm13
pcmpeqd %xmm14,%xmm14
movdqa 0x9a0(%rip),%xmm15
je     1240 <main+0x120>
jmp    11d0 <main+0xb0>
xor    %edx,%edx
movdqa 0x95b(%rip),%xmm4
movdqa 0x943(%rip),%xmm3
movdqa 0x92a(%rip),%xmm10
movdqa 0x911(%rip),%xmm9
test   $0x1,%sil
jne    1520 <main+0x400>
jmp    1625 <main+0x505>

LLVM IR (-O0):
@__WORDSIZE = global i32 0
@.str = [1 x i8] zeroinitializer
define i32 @main() {
%1 = alloca i32
%2 = alloca i8*
%3 = alloca i64
%4 = alloca i64
%5 = alloca i32
%6 = alloca i64
%7 = alloca i64
store i32 0, i32* %1
%8 = load i32, i32* @__WORDSIZE
%9 = sdiv i32 %8, 8
%10 = mul nsw i32 %9, 4
%11 = add nsw i32 %10, 1
%12 = load i32, i32* @__WORDSIZE
%13 = sdiv i32 %12, 8
%14 = add nsw i32 %11, %13
%15 = zext i32 %14 to i64
%16 = call i8* @llvm.stacksave()
store i8* %16, i8** %2
%17 = alloca i8, i64 %15
store i64 %15, i64* %3
%18 = call i64 @strlen(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%19 = icmp eq i64 %18, 0
%20 = zext i1 %19 to i32
%21 = call i32 @assert(i32 %20)
store i64 0, i64* %4
br label %22
22: ; preds = %94, %0
%23 = load i64, i64* %4
%24 = load i32, i32* @__WORDSIZE
%25 = sdiv i32 %24, 8
%26 = mul nsw i32 %25, 4
%27 = sext i32 %26 to i64
%28 = icmp ult i64 %23, %27
br i1 %28, label %29, label %97
29: ; preds = %22
%30 = load i64, i64* %4
%31 = urem i64 %30, 10
%32 = add i64 %31, 48
%33 = trunc i64 %32 to i8
%34 = load i64, i64* %4
%35 = getelementptr inbounds i8, i8* %17, i64 %34
store i8 %33, i8* %35
%36 = load i64, i64* %4
%37 = add i64 %36, 1
%38 = getelementptr inbounds i8, i8* %17, i64 %37
store i8 0, i8* %38
store i32 0, i32* %5
br label %39
39: ; preds = %90, %29
%40 = load i32, i32* %5
%41 = load i32, i32* @__WORDSIZE
%42 = sdiv i32 %41, 8
%43 = shl i32 1, %42
%44 = icmp ult i32 %40, %43
br i1 %44, label %45, label %93
45: ; preds = %39
store i64 0, i64* %6
br label %46
46: ; preds = %67, %45
%47 = load i64, i64* %6
%48 = load i32, i32* @__WORDSIZE
%49 = sdiv i32 %48, 8
%50 = sext i32 %49 to i64
%51 = icmp ult i64 %47, %50
br i1 %51, label %52, label %70
52: ; preds = %46
%53 = load i32, i32* %5
%54 = load i64, i64* %6
%55 = trunc i64 %54 to i32
%56 = shl i32 1, %55
%57 = and i32 %53, %56
%58 = icmp ne i32 %57, 0
%59 = zext i1 %58 to i64
%60 = select i1 %58, i32 255, i32 0
%61 = trunc i32 %60 to i8
%62 = load i64, i64* %4
%63 = add i64 %62, 2
%64 = load i64, i64* %6
%65 = add i64 %63, %64
%66 = getelementptr inbounds i8, i8* %17, i64 %65
store i8 %61, i8* %66
br label %67
67: ; preds = %52
%68 = load i64, i64* %6
%69 = add i64 %68, 1
store i64 %69, i64* %6
br label %46
70: ; preds = %46
store i64 0, i64* %7
br label %71
71: ; preds = %86, %70
%72 = load i64, i64* %7
%73 = load i64, i64* %4
%74 = icmp ule i64 %72, %73
br i1 %74, label %75, label %89
75: ; preds = %71
%76 = load i64, i64* %7
%77 = getelementptr inbounds i8, i8* %17, i64 %76
%78 = call i64 @strlen(i8* %77)
%79 = load i64, i64* %4
%80 = add i64 %79, 1
%81 = load i64, i64* %7
%82 = sub i64 %80, %81
%83 = icmp eq i64 %78, %82
%84 = zext i1 %83 to i32
%85 = call i32 @assert(i32 %84)
br label %86
86: ; preds = %75
%87 = load i64, i64* %7
%88 = add i64 %87, 1
store i64 %88, i64* %7
br label %71
89: ; preds = %71
br label %90
90: ; preds = %89
%91 = load i32, i32* %5
%92 = add i32 %91, 1
store i32 %92, i32* %5
br label %39
93: ; preds = %39
br label %94
94: ; preds = %93
%95 = load i64, i64* %4
%96 = add i64 %95, 1
store i64 %96, i64* %4
br label %22
97: ; preds = %22
store i32 0, i32* %1
%98 = load i8*, i8** %2
%99 = load i32, i32* %1
ret i32 %99
}

LLVM IR (-O2):
@__WORDSIZE = global i32 0
define i32 @main() {
%1 = load i32, i32* @__WORDSIZE
%2 = sdiv i32 %1, 8
%3 = shl nsw i32 %2, 2
%4 = add nsw i32 %2, 1
%5 = add nsw i32 %4, %3
%6 = zext i32 %5 to i64
%7 = alloca i8, i64 %6
%8 = tail call i32 @assert(i32 1)
%9 = load i32, i32* @__WORDSIZE
%10 = add i32 %9, 7
%11 = icmp ult i32 %10, 15
br i1 %11, label %119, label %17
12: ; preds = %110
%13 = shl nsw i32 %114, 2
%14 = sext i32 %13 to i64
%15 = icmp ult i64 %25, %14
%16 = add nuw i64 %19, 1
br i1 %15, label %17, label %119
17: ; preds = %0, %12
%18 = phi i32 [ %113, %12 ], [ %9, %0 ]
%19 = phi i64 [ %16, %12 ], [ 1, %0 ]
%20 = phi i64 [ %25, %12 ], [ 0, %0 ]
%21 = urem i64 %20, 10
%22 = trunc i64 %21 to i8
%23 = or i8 %22, 48
%24 = getelementptr inbounds i8, i8* %7, i64 %20
store i8 %23, i8* %24
%25 = add nuw i64 %20, 1
%26 = getelementptr inbounds i8, i8* %7, i64 %25
store i8 0, i8* %26
%27 = sdiv i32 %18, 8
%28 = add nuw i64 %20, 2
%29 = insertelement <2 x i32> <i32 0, i32 poison>, i32 %27, i64 1
br label %30
30: ; preds = %17, %110
%31 = phi <2 x i32> [ %29, %17 ], [ %118, %110 ]
%32 = extractelement <2 x i32> %31, i64 1
%33 = icmp eq i32 %32, 0
br i1 %33, label %99, label %34
34: ; preds = %30
%35 = sext i32 %32 to i64
%36 = icmp ult i32 %32, 16
br i1 %36, label %85, label %37
37: ; preds = %34
%38 = and i64 %35, -16
%39 = shufflevector <2 x i32> %31, <2 x i32> undef, <16 x i32> zeroinitializer
%40 = add nsw i64 %38, -16
%41 = lshr exact i64 %40, 4
%42 = add nuw nsw i64 %41, 1
%43 = and i64 %42, 1
%44 = icmp eq i64 %40, 0
br i1 %44, label %71, label %45
45: ; preds = %37
%46 = and i64 %42, 2305843009213693950
br label %47
47: ; preds = %47, %45
%48 = phi i64 [ 0, %45 ], [ %67, %47 ]
%49 = phi <16 x i32> [ <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>, %45 ], [ %68, %47 ]
%50 = phi i64 [ 0, %45 ], [ %69, %47 ]
%51 = shl nuw <16 x i32> <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>, %49
%52 = and <16 x i32> %51, %39
%53 = icmp ne <16 x i32> %52, zeroinitializer
%54 = sext <16 x i1> %53 to <16 x i8>
%55 = add i64 %28, %48
%56 = getelementptr inbounds i8, i8* %7, i64 %55
%57 = bitcast i8* %56 to <16 x i8>*
store <16 x i8> %54, <16 x i8>* %57
%58 = or i64 %48, 16
%59 = add <16 x i32> %49, <i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16>
%60 = shl nuw <16 x i32> <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>, %59
%61 = and <16 x i32> %60, %39
%62 = icmp ne <16 x i32> %61, zeroinitializer
%63 = sext <16 x i1> %62 to <16 x i8>
%64 = add i64 %28, %58
%65 = getelementptr inbounds i8, i8* %7, i64 %64
%66 = bitcast i8* %65 to <16 x i8>*
store <16 x i8> %63, <16 x i8>* %66
%67 = add nuw i64 %48, 32
%68 = add <16 x i32> %49, <i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32>
%69 = add i64 %50, 2
%70 = icmp eq i64 %69, %46
br i1 %70, label %71, label %47
71: ; preds = %47, %37
%72 = phi i64 [ 0, %37 ], [ %67, %47 ]
%73 = phi <16 x i32> [ <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>, %37 ], [ %68, %47 ]
%74 = icmp eq i64 %43, 0
br i1 %74, label %83, label %75
75: ; preds = %71
%76 = shl nuw <16 x i32> <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>, %73
%77 = and <16 x i32> %76, %39
%78 = icmp ne <16 x i32> %77, zeroinitializer
%79 = sext <16 x i1> %78 to <16 x i8>
%80 = add i64 %28, %72
%81 = getelementptr inbounds i8, i8* %7, i64 %80
%82 = bitcast i8* %81 to <16 x i8>*
store <16 x i8> %79, <16 x i8>* %82
br label %83
83: ; preds = %71, %75
%84 = icmp eq i64 %38, %35
br i1 %84, label %99, label %85
85: ; preds = %34, %83
%86 = phi i64 [ 0, %34 ], [ %38, %83 ]
%87 = extractelement <2 x i32> %31, i64 0
br label %88
88: ; preds = %85, %88
%89 = phi i64 [ %97, %88 ], [ %86, %85 ]
%90 = trunc i64 %89 to i32
%91 = shl nuw i32 1, %90
%92 = and i32 %91, %87
%93 = icmp ne i32 %92, 0
%94 = sext i1 %93 to i8
%95 = add i64 %28, %89
%96 = getelementptr inbounds i8, i8* %7, i64 %95
store i8 %94, i8* %96
%97 = add nuw i64 %89, 1
%98 = icmp eq i64 %97, %35
br i1 %98, label %99, label %88
99: ; preds = %88, %83, %30
br label %100
100: ; preds = %99, %100
%101 = phi i64 [ %108, %100 ], [ 0, %99 ]
%102 = getelementptr inbounds i8, i8* %7, i64 %101
%103 = call i64 @strlen(i8* %102)
%104 = sub i64 %25, %101
%105 = icmp eq i64 %103, %104
%106 = zext i1 %105 to i32
%107 = tail call i32 @assert(i32 %106)
%108 = add nuw i64 %101, 1
%109 = icmp eq i64 %108, %19
br i1 %109, label %110, label %100
110: ; preds = %100
%111 = extractelement <2 x i32> %31, i64 0
%112 = add i32 %111, 1
%113 = load i32, i32* @__WORDSIZE
%114 = sdiv i32 %113, 8
%115 = lshr i32 %112, %114
%116 = icmp eq i32 %115, 0
%117 = insertelement <2 x i32> poison, i32 %112, i64 0
%118 = insertelement <2 x i32> %117, i32 %114, i64 1
br i1 %116, label %30, label %12
119: ; preds = %12, %0
ret i32 0
}