#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 /*<<< orphan*/ printf(char *, int);
void sum() {
  int arr[302];
  int temp = 0, i, count = 0;
  for (i = 0; i < 302; i++) {
    arr[i] = 0;
  }
  arr[301] = 1;
  while (count < 1000) {
    for (i = 301; i >= 0; i--) {
      arr[i] = arr[i] * 2;
    }
    temp = 0;
    for (i = 301; i >= 0; i--) {
      arr[i] += temp;
      if (arr[i] > 9) {
        temp = arr[i] / 10;
        arr[i] = arr[i] % 10;
      } else {
        temp = 0;
      }
    }
    count++;
  }
  int sum = 0;
  for (i = 0; i < 302; i++) {
    sum += arr[i];
  }
  printf("%d\n", sum);
}


x86 assembly (clang, -O0):
<sum>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4d0,%rsp
movl   $0x0,-0x4c4(%rbp)
movl   $0x0,-0x4cc(%rbp)
movl   $0x0,-0x4c8(%rbp)
cmpl   $0x12e,-0x4c8(%rbp)
jge    116f <sum+0x5f>
movslq -0x4c8(%rbp),%rax
movl   $0x0,-0x4c0(%rbp,%rax,4)
mov    -0x4c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c8(%rbp)
jmp    1139 <sum+0x29>
movl   $0x1,-0xc(%rbp)
cmpl   $0x3e8,-0x4cc(%rbp)
jge    129d <sum+0x18d>
movl   $0x12d,-0x4c8(%rbp)
cmpl   $0x0,-0x4c8(%rbp)
jl     11d0 <sum+0xc0>
movslq -0x4c8(%rbp),%rax
mov    -0x4c0(%rbp,%rax,4),%ecx
shl    $0x1,%ecx
movslq -0x4c8(%rbp),%rax
mov    %ecx,-0x4c0(%rbp,%rax,4)
mov    -0x4c8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c8(%rbp)
jmp    1190 <sum+0x80>
movl   $0x0,-0x4c4(%rbp)
movl   $0x12d,-0x4c8(%rbp)
cmpl   $0x0,-0x4c8(%rbp)
jl     1289 <sum+0x179>
mov    -0x4c4(%rbp),%ecx
movslq -0x4c8(%rbp),%rax
add    -0x4c0(%rbp,%rax,4),%ecx
mov    %ecx,-0x4c0(%rbp,%rax,4)
movslq -0x4c8(%rbp),%rax
cmpl   $0x9,-0x4c0(%rbp,%rax,4)
09
jle    1266 <sum+0x156>
movslq -0x4c8(%rbp),%rax
mov    -0x4c0(%rbp,%rax,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4c4(%rbp)
movslq -0x4c8(%rbp),%rax
mov    -0x4c0(%rbp,%rax,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x4c8(%rbp),%rax
mov    %edx,-0x4c0(%rbp,%rax,4)
jmp    1270 <sum+0x160>
movl   $0x0,-0x4c4(%rbp)
jmp    1275 <sum+0x165>
mov    -0x4c8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c8(%rbp)
jmp    11e4 <sum+0xd4>
mov    -0x4cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4cc(%rbp)
jmp    1176 <sum+0x66>
movl   $0x0,-0x4d0(%rbp)
movl   $0x0,-0x4c8(%rbp)
cmpl   $0x12e,-0x4c8(%rbp)
jge    12ef <sum+0x1df>
movslq -0x4c8(%rbp),%rax
mov    -0x4c0(%rbp,%rax,4),%eax
add    -0x4d0(%rbp),%eax
mov    %eax,-0x4d0(%rbp)
mov    -0x4c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c8(%rbp)
jmp    12b1 <sum+0x1a1>
mov    -0x4d0(%rbp),%esi
lea    0xd04(%rip),%rdi
call   1030 <printf@plt>
add    $0x4d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sum>:
push   %rbx
sub    $0x4c0,%rsp
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x4b8,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x1,0x4b4(%rsp)
mov    $0xcccccccd,%eax
jmp    115f <sum+0x3f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebx
cmp    $0x3e8,%ebx
je     120d <sum+0xed>
mov    $0x12a,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rsp,%rcx,4),%xmm0
movdqu (%rsp,%rcx,4),%xmm1
paddd  %xmm1,%xmm1
paddd  %xmm0,%xmm0
movdqu %xmm1,(%rsp,%rcx,4)
movdqu %xmm0,-0x10(%rsp,%rcx,4)
cmp    $0xa,%rcx
je     11c0 <sum+0xa0>
movdqu -0x30(%rsp,%rcx,4),%xmm0
movdqu -0x20(%rsp,%rcx,4),%xmm1
paddd  %xmm1,%xmm1
paddd  %xmm0,%xmm0
movdqu %xmm1,-0x20(%rsp,%rcx,4)
movdqu %xmm0,-0x30(%rsp,%rcx,4)
add    $0xfffffffffffffff0,%rcx
jmp    1170 <sum+0x50>
nopw   0x0(%rax,%rax,1)
shll   0x14(%rsp)
shll   0x10(%rsp)
shll   0xc(%rsp)
shll   0x8(%rsp)
shll   0x4(%rsp)
shll   (%rsp)
xor    %edx,%edx
mov    $0x12d,%ecx
jmp    1201 <sum+0xe1>
mov    %edx,%esi
imul   %rax,%rsi
shr    $0x23,%rsi
lea    (%rsi,%rsi,1),%edi
lea    (%rdi,%rdi,4),%edi
sub    %edi,%edx
mov    %edx,(%rsp,%rcx,4)
mov    %esi,%edx
add    $0xffffffffffffffff,%rcx
jae    1150 <sum+0x30>
add    (%rsp,%rcx,4),%edx
cmp    $0xa,%edx
jge    11e0 <sum+0xc0>
xor    %esi,%esi
jmp    11f2 <sum+0xd2>
pxor   %xmm0,%xmm0
mov    $0x1c,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
paddd  -0x70(%rsp,%rax,4),%xmm0
paddd  -0x60(%rsp,%rax,4),%xmm1
cmp    $0x13c,%rax
je     125d <sum+0x13d>
paddd  -0x50(%rsp,%rax,4),%xmm0
paddd  -0x40(%rsp,%rax,4),%xmm1
paddd  -0x30(%rsp,%rax,4),%xmm0
paddd  -0x20(%rsp,%rax,4),%xmm1
paddd  -0x10(%rsp,%rax,4),%xmm0
paddd  (%rsp,%rax,4),%xmm1
add    $0x20,%rax
jmp    1220 <sum+0x100>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
add    0x4a0(%rsp),%esi
add    0x4a4(%rsp),%esi
add    0x4a8(%rsp),%esi
add    0x4ac(%rsp),%esi
add    0x4b0(%rsp),%esi
add    0x4b4(%rsp),%esi
lea    0xd58(%rip),%rdi
add    $0x4c0,%rsp
pop    %rbx
jmp    1030 <printf@plt>

LLVM IR (-O0):
@.str = [4 x i8] c"%d\0A\00"
define void @sum() {
%1 = alloca [302 x i32]
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
store i32 0, i32* %2
store i32 0, i32* %4
store i32 0, i32* %3
br label %6
6: ; preds = %13, %0
%7 = load i32, i32* %3
%8 = icmp slt i32 %7, 302
br i1 %8, label %9, label %16
9: ; preds = %6
%10 = load i32, i32* %3
%11 = sext i32 %10 to i64
%12 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %11
store i32 0, i32* %12
br label %13
13: ; preds = %9
%14 = load i32, i32* %3
%15 = add nsw i32 %14, 1
store i32 %15, i32* %3
br label %6
16: ; preds = %6
%17 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 301
store i32 1, i32* %17
br label %18
18: ; preds = %72, %16
%19 = load i32, i32* %4
%20 = icmp slt i32 %19, 1000
br i1 %20, label %21, label %75
21: ; preds = %18
store i32 301, i32* %3
br label %22
22: ; preds = %34, %21
%23 = load i32, i32* %3
%24 = icmp sge i32 %23, 0
br i1 %24, label %25, label %37
25: ; preds = %22
%26 = load i32, i32* %3
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %27
%29 = load i32, i32* %28
%30 = mul nsw i32 %29, 2
%31 = load i32, i32* %3
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %32
store i32 %30, i32* %33
br label %34
34: ; preds = %25
%35 = load i32, i32* %3
%36 = add nsw i32 %35, -1
store i32 %36, i32* %3
br label %22
37: ; preds = %22
store i32 0, i32* %2
store i32 301, i32* %3
br label %38
38: ; preds = %69, %37
%39 = load i32, i32* %3
%40 = icmp sge i32 %39, 0
br i1 %40, label %41, label %72
41: ; preds = %38
%42 = load i32, i32* %2
%43 = load i32, i32* %3
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %44
%46 = load i32, i32* %45
%47 = add nsw i32 %46, %42
store i32 %47, i32* %45
%48 = load i32, i32* %3
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %49
%51 = load i32, i32* %50
%52 = icmp sgt i32 %51, 9
br i1 %52, label %53, label %67
53: ; preds = %41
%54 = load i32, i32* %3
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %55
%57 = load i32, i32* %56
%58 = sdiv i32 %57, 10
store i32 %58, i32* %2
%59 = load i32, i32* %3
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %60
%62 = load i32, i32* %61
%63 = srem i32 %62, 10
%64 = load i32, i32* %3
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %65
store i32 %63, i32* %66
br label %68
67: ; preds = %41
store i32 0, i32* %2
br label %68
68: ; preds = %67, %53
br label %69
69: ; preds = %68
%70 = load i32, i32* %3
%71 = add nsw i32 %70, -1
store i32 %71, i32* %3
br label %38
72: ; preds = %38
%73 = load i32, i32* %4
%74 = add nsw i32 %73, 1
store i32 %74, i32* %4
br label %18
75: ; preds = %18
store i32 0, i32* %5
store i32 0, i32* %3
br label %76
76: ; preds = %86, %75
%77 = load i32, i32* %3
%78 = icmp slt i32 %77, 302
br i1 %78, label %79, label %89
79: ; preds = %76
%80 = load i32, i32* %3
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %81
%83 = load i32, i32* %82
%84 = load i32, i32* %5
%85 = add nsw i32 %84, %83
store i32 %85, i32* %5
br label %86
86: ; preds = %79
%87 = load i32, i32* %3
%88 = add nsw i32 %87, 1
store i32 %88, i32* %3
br label %76
89: ; preds = %76
%90 = load i32, i32* %5
%91 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %90)
ret void
}

LLVM IR (-O2):
@.str = [4 x i8] c"%d\0A\00"
define void @sum() {
%1 = alloca [302 x i32]
%2 = bitcast [302 x i32]* %1 to i8*
%3 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 301
store i32 1, i32* %3
%4 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 5
%5 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 4
%6 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 3
%7 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 2
%8 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 1
%9 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 0
br label %10
10: ; preds = %69, %0
%11 = phi i32 [ 0, %0 ], [ %70, %69 ]
br label %12
12: ; preds = %27, %10
%13 = phi i64 [ 0, %10 ], [ %40, %27 ]
%14 = sub nuw nsw i64 301, %13
%15 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %14
%16 = getelementptr inbounds i32, i32* %15, i64 -3
%17 = bitcast i32* %16 to <4 x i32>*
%18 = load <4 x i32>, <4 x i32>* %17
%19 = getelementptr inbounds i32, i32* %15, i64 -7
%20 = bitcast i32* %19 to <4 x i32>*
%21 = load <4 x i32>, <4 x i32>* %20
%22 = shl nsw <4 x i32> %18, <i32 1, i32 1, i32 1, i32 1>
%23 = shl nsw <4 x i32> %21, <i32 1, i32 1, i32 1, i32 1>
%24 = bitcast i32* %16 to <4 x i32>*
store <4 x i32> %22, <4 x i32>* %24
%25 = bitcast i32* %19 to <4 x i32>*
store <4 x i32> %23, <4 x i32>* %25
%26 = icmp eq i64 %13, 288
br i1 %26, label %41, label %27
27: ; preds = %12
%28 = sub nsw i64 293, %13
%29 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %28
%30 = getelementptr inbounds i32, i32* %29, i64 -3
%31 = bitcast i32* %30 to <4 x i32>*
%32 = load <4 x i32>, <4 x i32>* %31
%33 = getelementptr inbounds i32, i32* %29, i64 -7
%34 = bitcast i32* %33 to <4 x i32>*
%35 = load <4 x i32>, <4 x i32>* %34
%36 = shl nsw <4 x i32> %32, <i32 1, i32 1, i32 1, i32 1>
%37 = shl nsw <4 x i32> %35, <i32 1, i32 1, i32 1, i32 1>
%38 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> %36, <4 x i32>* %38
%39 = bitcast i32* %33 to <4 x i32>*
store <4 x i32> %37, <4 x i32>* %39
%40 = add nuw nsw i64 %13, 16
br label %12
41: ; preds = %12
%42 = load i32, i32* %4
%43 = shl nsw i32 %42, 1
store i32 %43, i32* %4
%44 = load i32, i32* %5
%45 = shl nsw i32 %44, 1
store i32 %45, i32* %5
%46 = load i32, i32* %6
%47 = shl nsw i32 %46, 1
store i32 %47, i32* %6
%48 = load i32, i32* %7
%49 = shl nsw i32 %48, 1
store i32 %49, i32* %7
%50 = load i32, i32* %8
%51 = shl nsw i32 %50, 1
store i32 %51, i32* %8
%52 = load i32, i32* %9
%53 = shl nsw i32 %52, 1
store i32 %53, i32* %9
br label %54
54: ; preds = %41, %64
%55 = phi i64 [ %67, %64 ], [ 301, %41 ]
%56 = phi i32 [ %66, %64 ], [ 0, %41 ]
%57 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %55
%58 = load i32, i32* %57
%59 = add nsw i32 %58, %56
%60 = icmp sgt i32 %59, 9
br i1 %60, label %61, label %64
61: ; preds = %54
%62 = udiv i32 %59, 10
%63 = urem i32 %59, 10
br label %64
64: ; preds = %54, %61
%65 = phi i32 [ %63, %61 ], [ %59, %54 ]
%66 = phi i32 [ %62, %61 ], [ 0, %54 ]
store i32 %65, i32* %57
%67 = add nsw i64 %55, -1
%68 = icmp eq i64 %55, 0
br i1 %68, label %69, label %54
69: ; preds = %64
%70 = add nuw nsw i32 %11, 1
%71 = icmp eq i32 %70, 1000
br i1 %71, label %72, label %10
72: ; preds = %69, %86
%73 = phi i64 [ %113, %86 ], [ 0, %69 ]
%74 = phi <4 x i32> [ %111, %86 ], [ zeroinitializer, %69 ]
%75 = phi <4 x i32> [ %112, %86 ], [ zeroinitializer, %69 ]
%76 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %73
%77 = bitcast i32* %76 to <4 x i32>*
%78 = load <4 x i32>, <4 x i32>* %77
%79 = getelementptr inbounds i32, i32* %76, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
%81 = load <4 x i32>, <4 x i32>* %80
%82 = add <4 x i32> %78, %74
%83 = add <4 x i32> %81, %75
%84 = or i64 %73, 8
%85 = icmp eq i64 %84, 296
br i1 %85, label %114, label %86
86: ; preds = %72
%87 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %84
%88 = bitcast i32* %87 to <4 x i32>*
%89 = load <4 x i32>, <4 x i32>* %88
%90 = getelementptr inbounds i32, i32* %87, i64 4
%91 = bitcast i32* %90 to <4 x i32>*
%92 = load <4 x i32>, <4 x i32>* %91
%93 = add <4 x i32> %89, %82
%94 = add <4 x i32> %92, %83
%95 = or i64 %73, 16
%96 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %95
%97 = bitcast i32* %96 to <4 x i32>*
%98 = load <4 x i32>, <4 x i32>* %97
%99 = getelementptr inbounds i32, i32* %96, i64 4
%100 = bitcast i32* %99 to <4 x i32>*
%101 = load <4 x i32>, <4 x i32>* %100
%102 = add <4 x i32> %98, %93
%103 = add <4 x i32> %101, %94
%104 = or i64 %73, 24
%105 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 %104
%106 = bitcast i32* %105 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = getelementptr inbounds i32, i32* %105, i64 4
%109 = bitcast i32* %108 to <4 x i32>*
%110 = load <4 x i32>, <4 x i32>* %109
%111 = add <4 x i32> %107, %102
%112 = add <4 x i32> %110, %103
%113 = add nuw nsw i64 %73, 32
br label %72
114: ; preds = %72
%115 = add <4 x i32> %83, %82
%116 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %115)
%117 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 296
%118 = load i32, i32* %117
%119 = add nsw i32 %118, %116
%120 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 297
%121 = load i32, i32* %120
%122 = add nsw i32 %121, %119
%123 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 298
%124 = load i32, i32* %123
%125 = add nsw i32 %124, %122
%126 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 299
%127 = load i32, i32* %126
%128 = add nsw i32 %127, %125
%129 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 300
%130 = load i32, i32* %129
%131 = add nsw i32 %130, %128
%132 = getelementptr inbounds [302 x i32], [302 x i32]* %1, i64 0, i64 301
%133 = load i32, i32* %132
%134 = add nsw i32 %133, %131
%135 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %134)
ret void
}