#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 /*<<< orphan*/ time_t;

/* Variables and functions */
int /*<<< orphan*/ printf(char *, unsigned char, ...);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
void parse_packet(unsigned char *packet) {
  int i = 0, j = 0;
  int signal = 0, attention = 0, meditation = 0, eeg_length = 0;
  unsigned long eeg_power[8];
  time_t tv;
  tv = time(NULL);
  for (i = 0; i < 32; i++) {
    switch (packet[i]) {
    case 2:
      signal = packet[++i];
      break;
    case 4:
      attention = packet[++i];
      break;
    case 5:
      meditation = packet[++i];
      break;
    case 131:
      eeg_length = packet[++i];
      for (j = 0; j < 8; j++) {
        eeg_power[j] = ((unsigned long)packet[++i] << 16) |
                       ((unsigned long)packet[++i] << 8) |
                       (unsigned long)packet[++i];
      }
      break;
    default:
      printf("huh what %02X\n", packet[i]);
      return;
    }
  }
  printf("%ld,%d,%d,%d,%lu,%lu,%lu,%lu,%lu,%lu,%lu,%lu\n", tv, signal,
         attention, meditation, eeg_power[0], eeg_power[1], eeg_power[2],
         eeg_power[3], eeg_power[4], eeg_power[5], eeg_power[6], eeg_power[7]);
}


x86 assembly (clang, -O0):
<parse_packet>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0xa0,%rsp
mov    %rdi,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1040 <time@plt>
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x20,-0x2c(%rbp)
jge    12f4 <parse_packet+0x1d4>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x88(%rbp)
sub    $0x2,%eax
je     11de <parse_packet+0xbe>
jmp    11a0 <parse_packet+0x80>
mov    -0x88(%rbp),%eax
sub    $0x4,%eax
je     11fa <parse_packet+0xda>
jmp    11b4 <parse_packet+0x94>
mov    -0x88(%rbp),%eax
sub    $0x5,%eax
je     1216 <parse_packet+0xf6>
jmp    11c8 <parse_packet+0xa8>
mov    -0x88(%rbp),%eax
sub    $0x83,%eax
je     1232 <parse_packet+0x112>
jmp    12c2 <parse_packet+0x1a2>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
jmp    12e1 <parse_packet+0x1c1>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
jmp    12e1 <parse_packet+0x1c1>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
jmp    12e1 <parse_packet+0x1c1>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    12bd <parse_packet+0x19d>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,%ecx
shl    $0x10,%rcx
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
shl    $0x8,%rax
or     %rax,%rcx
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
or     %rax,%rcx
movslq -0x30(%rbp),%rax
mov    %rcx,-0x80(%rbp,%rax,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1250 <parse_packet+0x130>
jmp    12e1 <parse_packet+0x1c1>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
lea    0xd2f(%rip),%rdi
movzbl (%rax,%rcx,1),%esi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    135b <parse_packet+0x23b>
jmp    12e6 <parse_packet+0x1c6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1176 <parse_packet+0x56>
mov    -0x84(%rbp),%eax
mov    %al,%sil
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x80(%rbp),%r9
mov    -0x78(%rbp),%r12
mov    -0x70(%rbp),%r15
mov    -0x68(%rbp),%r14
mov    -0x60(%rbp),%rbx
mov    -0x58(%rbp),%r11
mov    -0x50(%rbp),%r10
mov    -0x48(%rbp),%rax
lea    0xce1(%rip),%rdi
movzbl %sil,%esi
mov    %r12,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
add    $0xa0,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_packet>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r15
xor    %r14d,%r14d
xor    %edi,%edi
call   1040 <time@plt>
xor    %r8d,%r8d
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1167 <parse_packet+0x47>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x1(%r15,%rsi,1),%ecx
add    $0x1,%rsi
lea    0x1(%rsi),%r14d
cmp    $0x1f,%esi
jge    12c3 <parse_packet+0x1a3>
movslq %r14d,%rsi
movzbl (%r15,%rsi,1),%ebx
cmp    $0x3,%bl
jg     1190 <parse_packet+0x70>
cmp    $0x83,%bl
je     11b0 <parse_packet+0x90>
cmp    $0x2,%bl
jne    12f8 <parse_packet+0x1d8>
movzbl 0x1(%r15,%rsi,1),%edx
jmp    1156 <parse_packet+0x36>
nopw   0x0(%rax,%rax,1)
cmp    $0x4,%bl
je     1150 <parse_packet+0x30>
cmp    $0x5,%bl
jne    12f8 <parse_packet+0x1d8>
movzbl 0x1(%r15,%rsi,1),%r8d
jmp    1156 <parse_packet+0x36>
cs nopw 0x0(%rax,%rax,1)
movzbl 0x2(%rsi,%r15,1),%edi
shl    $0x10,%rdi
movzbl 0x3(%rsi,%r15,1),%ebp
shl    $0x8,%rbp
or     %rdi,%rbp
movzbl 0x4(%rsi,%r15,1),%r9d
or     %rbp,%r9
movzbl 0x5(%rsi,%r15,1),%edi
shl    $0x10,%rdi
movzbl 0x6(%rsi,%r15,1),%ebp
shl    $0x8,%rbp
or     %rdi,%rbp
movzbl 0x7(%rsi,%r15,1),%edi
or     %rbp,%rdi
mov    %rdi,0x10(%rsp)
movzbl 0x8(%rsi,%r15,1),%edi
shl    $0x10,%rdi
movzbl 0x9(%rsi,%r15,1),%ebp
shl    $0x8,%rbp
or     %rdi,%rbp
movzbl 0xa(%rsi,%r15,1),%edi
or     %rbp,%rdi
mov    %rdi,0x8(%rsp)
movzbl 0xb(%rsi,%r15,1),%edi
shl    $0x10,%rdi
movzbl 0xc(%rsi,%r15,1),%ebp
shl    $0x8,%rbp
or     %rdi,%rbp
movzbl 0xd(%rsi,%r15,1),%r10d
or     %rbp,%r10
movzbl 0xe(%rsi,%r15,1),%edi
shl    $0x10,%rdi
movzbl 0xf(%rsi,%r15,1),%ebx
shl    $0x8,%rbx
or     %rdi,%rbx
movzbl 0x10(%rsi,%r15,1),%r11d
or     %rbx,%r11
movzbl 0x11(%rsi,%r15,1),%edi
shl    $0x10,%rdi
movzbl 0x12(%rsi,%r15,1),%ebx
shl    $0x8,%rbx
or     %rdi,%rbx
movzbl 0x13(%rsi,%r15,1),%r12d
or     %rbx,%r12
movzbl 0x14(%rsi,%r15,1),%edi
shl    $0x10,%rdi
movzbl 0x15(%rsi,%r15,1),%ebx
shl    $0x8,%rbx
or     %rdi,%rbx
movzbl 0x16(%rsi,%r15,1),%r13d
or     %rbx,%r13
movzbl 0x17(%rsi,%r15,1),%edi
shl    $0x10,%rdi
movzbl 0x18(%rsi,%r15,1),%ebx
shl    $0x8,%rbx
or     %rdi,%rbx
movzbl 0x19(%r15,%rsi,1),%ebp
add    $0x19,%rsi
or     %rbx,%rbp
jmp    115a <parse_packet+0x3a>
sub    $0x8,%rsp
movzbl %al,%esi
lea    0xd3e(%rip),%rdi
xor    %eax,%eax
push   %rbp
push   %r13
push   %r12
push   %r11
push   %r10
push   0x38(%rsp)
push   0x48(%rsp)
call   1030 <printf@plt>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movzbl %bl,%esi
lea    0xcfe(%rip),%rdi
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>

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

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