#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 wint_t;
typedef int wchar_t;
typedef scalar_t__ u_char;

/* Variables and functions */
int *calloc(size_t, int);
size_t mbstowcs(int *, char const *, size_t);
size_t strlen(char const *);
int wcslen(int *);
wchar_t *makeextralist(int flags, const char *src) {
  wchar_t *dst, *d;
  size_t len;
  len = strlen(src);
  if ((dst = calloc(len + 10, sizeof(*dst))) == NULL) {
    return NULL;
  }
  if (mbstowcs(dst, src, len) == (size_t)-1) {
    size_t i;
    for (i = 0; i < len; i++) {
      dst[i] = (wint_t)(u_char)src[i];
    }
    d = dst + len;
  } else {
    d = dst + wcslen(dst);
  }
  if (flags & 0x1000) {
    *d++ = L'*';
    *d++ = L'?';
    *d++ = L'[';
    *d++ = L'#';
  }
  if (flags & 0x0004) {
    *d++ = L' ';
  }
  if (flags & 0x0008) {
    *d++ = L'\t';
  }
  if (flags & 0x0010) {
    *d++ = L'\n';
  }
  if ((flags & 0x0040) == 0) {
    *d++ = L'\\';
  }
  *d = L'\0';
  return dst;
}


x86 assembly (clang, -O0):
<makeextralist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
add    $0xa,%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    1189 <makeextralist+0x49>
movq   $0x0,-0x8(%rbp)
jmp    1329 <makeextralist+0x1e9>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1030 <mbstowcs@plt>
cmp    $0xffffffffffffffff,%rax
jne    11fd <makeextralist+0xbd>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    11e5 <makeextralist+0xa5>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsbq (%rax,%rcx,1),%rax
mov    %eax,%edx
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11ac <makeextralist+0x6c>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    1222 <makeextralist+0xe2>
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rdi
call   1050 <wcslen@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1000,%eax
cmp    $0x0,%eax
je     1287 <makeextralist+0x147>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0x2a,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0x3f,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0x5b,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0x23,(%rax)
mov    -0xc(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     12ab <makeextralist+0x16b>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0x20,(%rax)
mov    -0xc(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     12cf <makeextralist+0x18f>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0x9,(%rax)
mov    -0xc(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     12f3 <makeextralist+0x1b3>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0xa,(%rax)
mov    -0xc(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
jne    1317 <makeextralist+0x1d7>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0x5c,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<makeextralist>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rbp
mov    %edi,%r14d
mov    %rsi,%rdi
call   1040 <strlen@plt>
mov    %rax,%r15
lea    0xa(%rax),%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
test   %rax,%rax
je     11c6 <makeextralist+0x86>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <mbstowcs@plt>
cmp    $0xffffffffffffffff,%rax
je     121c <makeextralist+0xdc>
mov    %rbx,%rdi
call   1050 <wcslen@plt>
movslq %eax,%r15
lea    (%rbx,%r15,4),%rax
test   $0x1000,%r14d
jne    11d4 <makeextralist+0x94>
test   $0x4,%r14b
jne    11ea <makeextralist+0xaa>
test   $0x8,%r14b
jne    11fa <makeextralist+0xba>
test   $0x10,%r14b
jne    120a <makeextralist+0xca>
test   $0x40,%r14b
jne    11c0 <makeextralist+0x80>
movl   $0x5c,(%rax)
add    $0x4,%rax
movl   $0x0,(%rax)
mov    %rbx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
movdqa 0xe24(%rip),%xmm0
movdqu %xmm0,(%rax)
add    $0x10,%rax
test   $0x4,%r14b
je     11a4 <makeextralist+0x64>
movl   $0x20,(%rax)
add    $0x4,%rax
test   $0x8,%r14b
je     11aa <makeextralist+0x6a>
movl   $0x9,(%rax)
add    $0x4,%rax
test   $0x10,%r14b
je     11b0 <makeextralist+0x70>
movl   $0xa,(%rax)
add    $0x4,%rax
test   $0x40,%r14b
je     11b6 <makeextralist+0x76>
jmp    11c0 <makeextralist+0x80>
test   %r15,%r15
je     12b1 <makeextralist+0x171>
cmp    $0x8,%r15
jb     1241 <makeextralist+0x101>
lea    (%r15,%rbp,1),%rax
cmp    %rbx,%rax
jbe    12b9 <makeextralist+0x179>
lea    (%rbx,%r15,4),%rax
cmp    %rbp,%rax
jbe    12b9 <makeextralist+0x179>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r15,%rcx
mov    %r15,%rdx
and    $0x3,%rdx
je     1272 <makeextralist+0x132>
cs nopw 0x0(%rax,%rax,1)
nop
movsbl 0x0(%rbp,%rax,1),%esi
mov    %esi,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1260 <makeextralist+0x120>
cmp    $0x3,%rcx
jb     1191 <makeextralist+0x51>
nopl   0x0(%rax)
movsbl 0x0(%rbp,%rax,1),%ecx
mov    %ecx,(%rbx,%rax,4)
movsbl 0x1(%rbp,%rax,1),%ecx
mov    %ecx,0x4(%rbx,%rax,4)
movsbl 0x2(%rbp,%rax,1),%ecx
mov    %ecx,0x8(%rbx,%rax,4)
movsbl 0x3(%rbp,%rax,1),%ecx
mov    %ecx,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r15
jne    1280 <makeextralist+0x140>
jmp    1191 <makeextralist+0x51>
xor    %r15d,%r15d
jmp    1191 <makeextralist+0x51>
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     135f <makeextralist+0x21f>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   0x0(%rbp,%rcx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0x4(%rbp,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqu %xmm0,(%rbx,%rcx,4)
movdqu %xmm1,0x10(%rbx,%rcx,4)
movd   0x8(%rbp,%rcx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0xc(%rbp,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqu %xmm0,0x20(%rbx,%rcx,4)
movdqu %xmm1,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    12f0 <makeextralist+0x1b0>
jmp    1361 <makeextralist+0x221>
xor    %ecx,%ecx
test   $0x1,%dl
je     1397 <makeextralist+0x257>
movd   0x0(%rbp,%rcx,1),%xmm0
movd   0x4(%rbp,%rcx,1),%xmm1
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
movdqu %xmm0,(%rbx,%rcx,4)
movdqu %xmm1,0x10(%rbx,%rcx,4)
cmp    %rax,%r15
je     1191 <makeextralist+0x51>
jmp    1243 <makeextralist+0x103>

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

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