#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 */
scalar_t__ expo(int, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, char *);
int /*<<< orphan*/ stack(int *);
int main(void) {
  char list[100];
  int counter = 0;
  char temp;
  do {
    scanf("%c", &temp);
    if (temp == '\n') {
      break;
    }
    if (temp == ' ') {
      list[counter] = '-';
      counter++;
      continue;
    }
    list[counter] = temp;
    counter++;
  } while (1);
  int intlist[100] = {0};
  char revlist[100];
  int i;
  for (i = 0; i < counter; i++) {
    revlist[i] = list[counter - 1 - i];
  }
  revlist[counter] = '*';
  int tet = 0, sum, exp, cot = 0, temp1;
  do {
    exp = 0;
    sum = 0;
    while (revlist[tet] != '-') {
      if (revlist[tet] == '*') {
        break;
      }
      temp1 = revlist[tet] - '0';
      sum += expo(temp1, exp);
      exp++;
      tet++;
    }
    intlist[cot] = sum;
    cot++;
    if (revlist[tet] == '-') {
      tet++;
      continue;
    }
  } while (revlist[tet] != '*');
  printf("Your list: ");
  stack(intlist);
  printf("\n");
  int sum2 = 0;
  for (i = 0; i < 100; i++) {
    sum2 += intlist[i];
  }
  printf("The sum of the integers is: %d\n", sum2);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2a0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x74(%rbp)
lea    0xe90(%rip),%rdi
lea    -0x75(%rbp),%rsi
call   1050 <scanf@plt>
movsbl -0x75(%rbp),%eax
cmp    $0xa,%eax
jne    118b <main+0x3b>
jmp    11d2 <main+0x82>
movsbl -0x75(%rbp),%eax
cmp    $0x20,%eax
jne    11af <main+0x5f>
movslq -0x74(%rbp),%rax
movb   $0x2d,-0x70(%rbp,%rax,1)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    11c3 <main+0x73>
mov    -0x75(%rbp),%cl
movslq -0x74(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    $0x1,%al
test   $0x1,%al
jne    1169 <main+0x19>
jmp    11d2 <main+0x82>
lea    -0x210(%rbp),%rdi
xor    %esi,%esi
mov    $0x190,%edx
call   1040 <memset@plt>
movl   $0x0,-0x284(%rbp)
mov    -0x284(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1232 <main+0xe2>
mov    -0x74(%rbp),%eax
sub    $0x1,%eax
sub    -0x284(%rbp),%eax
cltq
mov    -0x70(%rbp,%rax,1),%cl
movslq -0x284(%rbp),%rax
mov    %cl,-0x280(%rbp,%rax,1)
mov    -0x284(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x284(%rbp)
jmp    11ef <main+0x9f>
movslq -0x74(%rbp),%rax
movb   $0x2a,-0x280(%rbp,%rax,1)
2a
movl   $0x0,-0x288(%rbp)
movl   $0x0,-0x294(%rbp)
movl   $0x0,-0x290(%rbp)
movl   $0x0,-0x28c(%rbp)
movslq -0x288(%rbp),%rax
movsbl -0x280(%rbp,%rax,1),%eax
ff
cmp    $0x2d,%eax
je     12fa <main+0x1aa>
movslq -0x288(%rbp),%rax
movsbl -0x280(%rbp,%rax,1),%eax
ff
cmp    $0x2a,%eax
jne    129b <main+0x14b>
jmp    12fa <main+0x1aa>
movslq -0x288(%rbp),%rax
movsbl -0x280(%rbp,%rax,1),%eax
ff
sub    $0x30,%eax
mov    %eax,-0x298(%rbp)
mov    -0x298(%rbp),%edi
mov    -0x290(%rbp),%esi
call   1070 <expo@plt>
mov    %rax,%rcx
movslq -0x28c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x28c(%rbp)
mov    -0x290(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x290(%rbp)
mov    -0x288(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x288(%rbp)
jmp    1266 <main+0x116>
mov    -0x28c(%rbp),%ecx
movslq -0x294(%rbp),%rax
mov    %ecx,-0x210(%rbp,%rax,4)
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
movslq -0x288(%rbp),%rax
movsbl -0x280(%rbp,%rax,1),%eax
ff
cmp    $0x2d,%eax
jne    1349 <main+0x1f9>
mov    -0x288(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x288(%rbp)
jmp    134e <main+0x1fe>
jmp    134e <main+0x1fe>
movslq -0x288(%rbp),%rax
movsbl -0x280(%rbp,%rax,1),%eax
ff
cmp    $0x2a,%eax
jne    1252 <main+0x102>
lea    0xc96(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x210(%rbp),%rdi
call   1060 <stack@plt>
lea    0xca6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x29c(%rbp)
movl   $0x0,-0x284(%rbp)
cmpl   $0x64,-0x284(%rbp)
jge    13dd <main+0x28d>
movslq -0x284(%rbp),%rax
mov    -0x210(%rbp,%rax,4),%eax
add    -0x29c(%rbp),%eax
mov    %eax,-0x29c(%rbp)
mov    -0x284(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x284(%rbp)
jmp    13a2 <main+0x252>
mov    -0x29c(%rbp),%esi
lea    0xc25(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x278,%rsp
movabs $0xffffffff00000000,%rbx
ff ff ff
movabs $0x100000000,%r12
movabs $0x200000000,%rax
mov    %rax,0x8(%rsp)
xor    %r13d,%r13d
lea    0xe62(%rip),%r14
lea    0x7(%rsp),%r15
xor    %ebp,%ebp
jmp    11c9 <main+0x69>
nopw   0x0(%rax,%rax,1)
mov    %eax,%ecx
mov    %cl,0x210(%rsp,%rbp,1)
add    $0x1,%rbp
add    $0x1,%r13b
add    %rbx,%r12
add    %rbx,0x8(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
call   1060 <scanf@plt>
mov    $0x2d,%cl
movzbl 0x7(%rsp),%eax
cmp    $0x20,%al
je     11b2 <main+0x52>
cmp    $0xa,%al
jne    11b0 <main+0x50>
lea    0x80(%rsp),%rdi
xor    %r14d,%r14d
mov    $0x190,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    %ebp,%r10d
test   %ebp,%ebp
je     1295 <main+0x135>
cmp    $0x8,%r10d
jae    1440 <main+0x2e0>
xor    %ecx,%ecx
mov    %ebp,%edx
sub    %ecx,%edx
lea    0x1(%rcx),%rax
test   $0x1,%dl
je     123a <main+0xda>
mov    %rcx,%rdx
imul   %rbx,%rdx
sub    %r12,%rdx
sar    $0x20,%rdx
mov    0x210(%rsp,%rdx,1),%dl
mov    %dl,0x10(%rsp,%rcx,1)
mov    %rax,%rcx
cmp    %rax,%r10
je     1295 <main+0x135>
movabs $0xfffffffe00000000,%r8
ff ff ff
mov    %ebp,%edx
imul   %rcx,%rbx
mov    %rbx,%rsi
sub    0x8(%rsp),%rsi
sub    %r12,%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
sar    $0x20,%rdi
movzbl 0x210(%rsp,%rdi,1),%eax
mov    %al,0x10(%rsp,%rcx,1)
mov    %rsi,%rax
sar    $0x20,%rax
movzbl 0x210(%rsp,%rax,1),%eax
mov    %al,0x11(%rsp,%rcx,1)
add    $0x2,%rcx
add    %r8,%rsi
add    %r8,%rbx
cmp    %rcx,%rdx
jne    1260 <main+0x100>
movb   $0x2a,0x10(%rsp,%r10,1)
xor    %r15d,%r15d
jmp    12c8 <main+0x168>
mov    %ebp,0x80(%rsp,%r15,4)
add    $0x1,%r15
xor    %eax,%eax
cmp    $0x2d,%dil
sete   %al
mov    %r14d,%r14d
add    %rax,%r14
add    %rbx,%r14
movslq %r14d,%rax
cmpb   $0x2a,0x10(%rsp,%rax,1)
je     1302 <main+0x1a2>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%r12
add    $0x10,%r12
xor    %ebx,%ebx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsbl (%r12,%rbx,1),%edi
cmp    $0x2a,%edi
je     12a0 <main+0x140>
cmp    $0x2d,%dil
je     12a0 <main+0x140>
add    $0xffffffd0,%edi
mov    %ebx,%esi
call   1080 <expo@plt>
add    %eax,%ebp
add    $0x1,%rbx
jmp    12e0 <main+0x180>
lea    0xcfa(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x80(%rsp),%rdi
call   1070 <stack@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movdqa 0x90(%rsp),%xmm0
paddd  0x80(%rsp),%xmm0
paddd  0xa0(%rsp),%xmm0
paddd  0xb0(%rsp),%xmm0
paddd  0xc0(%rsp),%xmm0
paddd  0xd0(%rsp),%xmm0
paddd  0xe0(%rsp),%xmm0
paddd  0xf0(%rsp),%xmm0
paddd  0x100(%rsp),%xmm0
paddd  0x110(%rsp),%xmm0
paddd  0x120(%rsp),%xmm0
paddd  0x130(%rsp),%xmm0
paddd  0x140(%rsp),%xmm0
paddd  0x150(%rsp),%xmm0
paddd  0x160(%rsp),%xmm0
paddd  0x170(%rsp),%xmm0
paddd  0x180(%rsp),%xmm0
paddd  0x190(%rsp),%xmm0
paddd  0x1a0(%rsp),%xmm0
paddd  0x1b0(%rsp),%xmm0
paddd  0x1c0(%rsp),%xmm0
paddd  0x1d0(%rsp),%xmm0
paddd  0x1e0(%rsp),%xmm0
paddd  0x1f0(%rsp),%xmm0
paddd  0x200(%rsp),%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
lea    0xbea(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x278,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r10),%rax
lea    -0x1(%rbp),%edx
mov    %edx,%esi
sub    %eax,%esi
xor    %ecx,%ecx
cmp    %edx,%esi
jg     1211 <main+0xb1>
shr    $0x20,%rax
jne    1211 <main+0xb1>
movzbl %r13b,%r8d
cmp    $0x20,%r10d
jae    1470 <main+0x310>
xor    %ecx,%ecx
jmp    1544 <main+0x3e4>
mov    %r12,%rdx
neg    %rdx
mov    %ebp,%r11d
mov    %ebp,%r9d
and    $0x1f,%r9d
mov    %r10,%rcx
sub    %r9,%rcx
mov    %r8d,%eax
and    $0x1f,%eax
sub    %rax,%r11
xor    %esi,%esi
pxor   %xmm0,%xmm0
movabs $0xffffffe000000000,%rax
ff ff ff
nop
mov    %rdx,%rdi
sar    $0x20,%rdi
movdqu 0x1f1(%rsp,%rdi,1),%xmm1
movdqu 0x201(%rsp,%rdi,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqa %xmm2,0x10(%rsp,%rsi,1)
movdqa %xmm1,0x20(%rsp,%rsi,1)
add    $0x20,%rsi
add    %rax,%rdx
cmp    %rsi,%r11
jne    14a0 <main+0x340>
test   %r9,%r9
je     1295 <main+0x135>
cmp    $0x8,%r9d
jb     1211 <main+0xb1>
mov    %rcx,%rdx
mov    %ebp,%edi
mov    %ebp,%r9d
and    $0x7,%r9d
mov    %r10,%rcx
sub    %r9,%rcx
mov    %rdx,%rsi
imul   %rbx,%rsi
sub    %r12,%rsi
and    $0x7,%r8d
sub    %r8,%rdi
pxor   %xmm0,%xmm0
movabs $0xfffffff800000000,%r8
ff ff ff
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rsi,%rax
sar    $0x20,%rax
movq   0x209(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x10(%rsp,%rdx,1)
add    $0x8,%rdx
add    %r8,%rsi
cmp    %rdx,%rdi
jne    1580 <main+0x420>
test   %r9,%r9
jne    1211 <main+0xb1>
jmp    1295 <main+0x135>

LLVM IR (-O0):
@.str = [3 x i8] c"%c\00"
@.str.1 = [12 x i8] c"Your list: \00"
@.str.2 = [2 x i8] c"\0A\00"
@.str.3 = [32 x i8] c"The sum of the integers is: %d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [100 x i8]
%3 = alloca i32
%4 = alloca i8
%5 = alloca [100 x i32]
%6 = alloca [100 x i8]
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %3
br label %14
14: ; preds = %37, %0
%15 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %4)
%16 = load i8, i8* %4
%17 = sext i8 %16 to i32
%18 = icmp eq i32 %17, 10
br i1 %18, label %19, label %20
19: ; preds = %14
br label %38
20: ; preds = %14
%21 = load i8, i8* %4
%22 = sext i8 %21 to i32
%23 = icmp eq i32 %22, 32
br i1 %23, label %24, label %30
24: ; preds = %20
%25 = load i32, i32* %3
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %26
store i8 45, i8* %27
%28 = load i32, i32* %3
%29 = add nsw i32 %28, 1
store i32 %29, i32* %3
br label %37
30: ; preds = %20
%31 = load i8, i8* %4
%32 = load i32, i32* %3
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %33
store i8 %31, i8* %34
%35 = load i32, i32* %3
%36 = add nsw i32 %35, 1
store i32 %36, i32* %3
br label %37
37: ; preds = %30, %24
br i1 true, label %14, label %38
38: ; preds = %37, %19
%39 = bitcast [100 x i32]* %5 to i8*
store i32 0, i32* %7
br label %40
40: ; preds = %55, %38
%41 = load i32, i32* %7
%42 = load i32, i32* %3
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %58
44: ; preds = %40
%45 = load i32, i32* %3
%46 = sub nsw i32 %45, 1
%47 = load i32, i32* %7
%48 = sub nsw i32 %46, %47
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %49
%51 = load i8, i8* %50
%52 = load i32, i32* %7
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %53
store i8 %51, i8* %54
br label %55
55: ; preds = %44
%56 = load i32, i32* %7
%57 = add nsw i32 %56, 1
store i32 %57, i32* %7
br label %40
58: ; preds = %40
%59 = load i32, i32* %3
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %60
store i8 42, i8* %61
store i32 0, i32* %8
store i32 0, i32* %11
br label %62
62: ; preds = %113, %58
store i32 0, i32* %10
store i32 0, i32* %9
br label %63
63: ; preds = %78, %62
%64 = load i32, i32* %8
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %65
%67 = load i8, i8* %66
%68 = sext i8 %67 to i32
%69 = icmp ne i32 %68, 45
br i1 %69, label %70, label %96
70: ; preds = %63
%71 = load i32, i32* %8
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %72
%74 = load i8, i8* %73
%75 = sext i8 %74 to i32
%76 = icmp eq i32 %75, 42
br i1 %76, label %77, label %78
77: ; preds = %70
br label %96
78: ; preds = %70
%79 = load i32, i32* %8
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %80
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
%84 = sub nsw i32 %83, 48
store i32 %84, i32* %12
%85 = load i32, i32* %12
%86 = load i32, i32* %10
%87 = call i64 @expo(i32 %85, i32 %86)
%88 = load i32, i32* %9
%89 = sext i32 %88 to i64
%90 = add nsw i64 %89, %87
%91 = trunc i64 %90 to i32
store i32 %91, i32* %9
%92 = load i32, i32* %10
%93 = add nsw i32 %92, 1
store i32 %93, i32* %10
%94 = load i32, i32* %8
%95 = add nsw i32 %94, 1
store i32 %95, i32* %8
br label %63
96: ; preds = %77, %63
%97 = load i32, i32* %9
%98 = load i32, i32* %11
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [100 x i32], [100 x i32]* %5, i64 0, i64 %99
store i32 %97, i32* %100
%101 = load i32, i32* %11
%102 = add nsw i32 %101, 1
store i32 %102, i32* %11
%103 = load i32, i32* %8
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %104
%106 = load i8, i8* %105
%107 = sext i8 %106 to i32
%108 = icmp eq i32 %107, 45
br i1 %108, label %109, label %112
109: ; preds = %96
%110 = load i32, i32* %8
%111 = add nsw i32 %110, 1
store i32 %111, i32* %8
br label %113
112: ; preds = %96
br label %113
113: ; preds = %112, %109
%114 = load i32, i32* %8
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %115
%117 = load i8, i8* %116
%118 = sext i8 %117 to i32
%119 = icmp ne i32 %118, 42
br i1 %119, label %62, label %120
120: ; preds = %113
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0))
%122 = getelementptr inbounds [100 x i32], [100 x i32]* %5, i64 0, i64 0
%123 = call i32 @stack(i32* %122)
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %13
store i32 0, i32* %7
br label %125
125: ; preds = %135, %120
%126 = load i32, i32* %7
%127 = icmp slt i32 %126, 100
br i1 %127, label %128, label %138
128: ; preds = %125
%129 = load i32, i32* %7
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [100 x i32], [100 x i32]* %5, i64 0, i64 %130
%132 = load i32, i32* %131
%133 = load i32, i32* %13
%134 = add nsw i32 %133, %132
store i32 %134, i32* %13
br label %135
135: ; preds = %128
%136 = load i32, i32* %7
%137 = add nsw i32 %136, 1
store i32 %137, i32* %7
br label %125
138: ; preds = %125
%139 = load i32, i32* %13
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0), i32 %139)
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%c\00"
@.str.1 = [12 x i8] c"Your list: \00"
@.str.3 = [32 x i8] c"The sum of the integers is: %d\0A\00"
define i32 @main() {
%1 = alloca [100 x i8]
%2 = alloca i8
%3 = alloca [100 x i32]
%4 = alloca [100 x i8]
%5 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 0
br label %6
6: ; preds = %11, %0
%7 = phi i64 [ %14, %11 ], [ 0, %0 ]
%8 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %2)
%9 = load i8, i8* %2
switch i8 %9, label %10 [
i8 10, label %15
i8 32, label %11
]
10: ; preds = %6
br label %11
11: ; preds = %6, %10
%12 = phi i8 [ %9, %10 ], [ 45, %6 ]
%13 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %7
store i8 %12, i8* %13
%14 = add nuw i64 %7, 1
br label %6
15: ; preds = %6
%16 = trunc i64 %7 to i32
%17 = bitcast [100 x i32]* %3 to i8*
%18 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%19 = icmp eq i32 %16, 0
%20 = and i64 %7, 4294967295
br i1 %19, label %119, label %21
21: ; preds = %15
%22 = icmp ult i64 %20, 8
br i1 %22, label %82, label %23
23: ; preds = %21
%24 = add nsw i64 %20, -1
%25 = add i32 %16, -1
%26 = trunc i64 %24 to i32
%27 = sub i32 %25, %26
%28 = icmp sgt i32 %27, %25
%29 = icmp ugt i64 %24, 4294967295
%30 = or i1 %28, %29
br i1 %30, label %82, label %31
31: ; preds = %23
%32 = icmp ult i64 %20, 32
br i1 %32, label %61, label %33
33: ; preds = %31
%34 = and i64 %7, 31
%35 = sub nsw i64 %20, %34
br label %36
36: ; preds = %36, %33
%37 = phi i64 [ 0, %33 ], [ %55, %36 ]
%38 = xor i64 %37, -1
%39 = add i64 %7, %38
%40 = shl i64 %39, 32
%41 = ashr exact i64 %40, 32
%42 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %41
%43 = getelementptr inbounds i8, i8* %42, i64 -15
%44 = bitcast i8* %43 to <16 x i8>*
%45 = load <16 x i8>, <16 x i8>* %44
%46 = shufflevector <16 x i8> %45, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%47 = getelementptr inbounds i8, i8* %42, i64 -31
%48 = bitcast i8* %47 to <16 x i8>*
%49 = load <16 x i8>, <16 x i8>* %48
%50 = shufflevector <16 x i8> %49, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%51 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %37
%52 = bitcast i8* %51 to <16 x i8>*
store <16 x i8> %46, <16 x i8>* %52
%53 = getelementptr inbounds i8, i8* %51, i64 16
%54 = bitcast i8* %53 to <16 x i8>*
store <16 x i8> %50, <16 x i8>* %54
%55 = add nuw i64 %37, 32
%56 = icmp eq i64 %55, %35
br i1 %56, label %57, label %36
57: ; preds = %36
%58 = icmp eq i64 %34, 0
br i1 %58, label %119, label %59
59: ; preds = %57
%60 = icmp ult i64 %34, 8
br i1 %60, label %82, label %61
61: ; preds = %31, %59
%62 = phi i64 [ %35, %59 ], [ 0, %31 ]
%63 = and i64 %7, 7
%64 = sub nsw i64 %20, %63
br label %65
65: ; preds = %65, %61
%66 = phi i64 [ %62, %61 ], [ %78, %65 ]
%67 = xor i64 %66, -1
%68 = add i64 %7, %67
%69 = shl i64 %68, 32
%70 = ashr exact i64 %69, 32
%71 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %70
%72 = getelementptr inbounds i8, i8* %71, i64 -7
%73 = bitcast i8* %72 to <8 x i8>*
%74 = load <8 x i8>, <8 x i8>* %73
%75 = shufflevector <8 x i8> %74, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%76 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %66
%77 = bitcast i8* %76 to <8 x i8>*
store <8 x i8> %75, <8 x i8>* %77
%78 = add nuw i64 %66, 8
%79 = icmp eq i64 %78, %64
br i1 %79, label %80, label %65
80: ; preds = %65
%81 = icmp eq i64 %63, 0
br i1 %81, label %119, label %82
82: ; preds = %23, %21, %59, %80
%83 = phi i64 [ 0, %21 ], [ 0, %23 ], [ %35, %59 ], [ %64, %80 ]
%84 = sub i64 %7, %83
%85 = add nsw i64 %83, 1
%86 = and i64 %84, 1
%87 = icmp eq i64 %86, 0
br i1 %87, label %97, label %88
88: ; preds = %82
%89 = xor i64 %83, -1
%90 = add i64 %7, %89
%91 = shl i64 %90, 32
%92 = ashr exact i64 %91, 32
%93 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %92
%94 = load i8, i8* %93
%95 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %83
store i8 %94, i8* %95
%96 = add nuw nsw i64 %83, 1
br label %97
97: ; preds = %88, %82
%98 = phi i64 [ %83, %82 ], [ %96, %88 ]
%99 = icmp eq i64 %20, %85
br i1 %99, label %119, label %100
100: ; preds = %97, %100
%101 = phi i64 [ %117, %100 ], [ %98, %97 ]
%102 = xor i64 %101, -1
%103 = add i64 %7, %102
%104 = shl i64 %103, 32
%105 = ashr exact i64 %104, 32
%106 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %105
%107 = load i8, i8* %106
%108 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %101
store i8 %107, i8* %108
%109 = add nuw nsw i64 %101, 1
%110 = sub i64 4294967294, %101
%111 = add i64 %7, %110
%112 = shl i64 %111, 32
%113 = ashr exact i64 %112, 32
%114 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %113
%115 = load i8, i8* %114
%116 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %109
store i8 %115, i8* %116
%117 = add nuw nsw i64 %101, 2
%118 = icmp eq i64 %117, %20
br i1 %118, label %119, label %100
119: ; preds = %97, %100, %57, %80, %15
%120 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %20
store i8 42, i8* %120
br label %121
121: ; preds = %139, %119
%122 = phi i64 [ %142, %139 ], [ 0, %119 ]
%123 = phi i32 [ %145, %139 ], [ 0, %119 ]
%124 = sext i32 %123 to i64
br label %125
125: ; preds = %131, %121
%126 = phi i64 [ %138, %131 ], [ %124, %121 ]
%127 = phi i32 [ %136, %131 ], [ 0, %121 ]
%128 = phi i32 [ %137, %131 ], [ 0, %121 ]
%129 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %126
%130 = load i8, i8* %129
switch i8 %130, label %131 [
i8 45, label %139
i8 42, label %139
]
131: ; preds = %125
%132 = sext i8 %130 to i32
%133 = add nsw i32 %132, -48
%134 = call i64 @expo(i32 %133, i32 %128)
%135 = trunc i64 %134 to i32
%136 = add i32 %127, %135
%137 = add nuw nsw i32 %128, 1
%138 = add i64 %126, 1
br label %125
139: ; preds = %125, %125
%140 = trunc i64 %126 to i32
%141 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %122
store i32 %127, i32* %141
%142 = add nuw i64 %122, 1
%143 = icmp eq i8 %130, 45
%144 = zext i1 %143 to i32
%145 = add nsw i32 %140, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %146
%148 = load i8, i8* %147
%149 = icmp eq i8 %148, 42
br i1 %149, label %150, label %121
150: ; preds = %139
%151 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0))
%152 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 0
%153 = call i32 @stack(i32* %152)
%154 = call i32 @putchar(i32 10)
%155 = bitcast [100 x i32]* %3 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 4
%158 = bitcast i32* %157 to <4 x i32>*
%159 = load <4 x i32>, <4 x i32>* %158
%160 = add <4 x i32> %159, %156
%161 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 8
%162 = bitcast i32* %161 to <4 x i32>*
%163 = load <4 x i32>, <4 x i32>* %162
%164 = add <4 x i32> %163, %160
%165 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 12
%166 = bitcast i32* %165 to <4 x i32>*
%167 = load <4 x i32>, <4 x i32>* %166
%168 = add <4 x i32> %167, %164
%169 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 16
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = add <4 x i32> %171, %168
%173 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 20
%174 = bitcast i32* %173 to <4 x i32>*
%175 = load <4 x i32>, <4 x i32>* %174
%176 = add <4 x i32> %175, %172
%177 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 24
%178 = bitcast i32* %177 to <4 x i32>*
%179 = load <4 x i32>, <4 x i32>* %178
%180 = add <4 x i32> %179, %176
%181 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 28
%182 = bitcast i32* %181 to <4 x i32>*
%183 = load <4 x i32>, <4 x i32>* %182
%184 = add <4 x i32> %183, %180
%185 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 32
%186 = bitcast i32* %185 to <4 x i32>*
%187 = load <4 x i32>, <4 x i32>* %186
%188 = add <4 x i32> %187, %184
%189 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 36
%190 = bitcast i32* %189 to <4 x i32>*
%191 = load <4 x i32>, <4 x i32>* %190
%192 = add <4 x i32> %191, %188
%193 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 40
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = add <4 x i32> %195, %192
%197 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 44
%198 = bitcast i32* %197 to <4 x i32>*
%199 = load <4 x i32>, <4 x i32>* %198
%200 = add <4 x i32> %199, %196
%201 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 48
%202 = bitcast i32* %201 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = add <4 x i32> %203, %200
%205 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 52
%206 = bitcast i32* %205 to <4 x i32>*
%207 = load <4 x i32>, <4 x i32>* %206
%208 = add <4 x i32> %207, %204
%209 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 56
%210 = bitcast i32* %209 to <4 x i32>*
%211 = load <4 x i32>, <4 x i32>* %210
%212 = add <4 x i32> %211, %208
%213 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 60
%214 = bitcast i32* %213 to <4 x i32>*
%215 = load <4 x i32>, <4 x i32>* %214
%216 = add <4 x i32> %215, %212
%217 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 64
%218 = bitcast i32* %217 to <4 x i32>*
%219 = load <4 x i32>, <4 x i32>* %218
%220 = add <4 x i32> %219, %216
%221 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 68
%222 = bitcast i32* %221 to <4 x i32>*
%223 = load <4 x i32>, <4 x i32>* %222
%224 = add <4 x i32> %223, %220
%225 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 72
%226 = bitcast i32* %225 to <4 x i32>*
%227 = load <4 x i32>, <4 x i32>* %226
%228 = add <4 x i32> %227, %224
%229 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 76
%230 = bitcast i32* %229 to <4 x i32>*
%231 = load <4 x i32>, <4 x i32>* %230
%232 = add <4 x i32> %231, %228
%233 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 80
%234 = bitcast i32* %233 to <4 x i32>*
%235 = load <4 x i32>, <4 x i32>* %234
%236 = add <4 x i32> %235, %232
%237 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 84
%238 = bitcast i32* %237 to <4 x i32>*
%239 = load <4 x i32>, <4 x i32>* %238
%240 = add <4 x i32> %239, %236
%241 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 88
%242 = bitcast i32* %241 to <4 x i32>*
%243 = load <4 x i32>, <4 x i32>* %242
%244 = add <4 x i32> %243, %240
%245 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 92
%246 = bitcast i32* %245 to <4 x i32>*
%247 = load <4 x i32>, <4 x i32>* %246
%248 = add <4 x i32> %247, %244
%249 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 96
%250 = bitcast i32* %249 to <4 x i32>*
%251 = load <4 x i32>, <4 x i32>* %250
%252 = add <4 x i32> %251, %248
%253 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %252)
%254 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0), i32 %253)
ret i32 0
}