void sum_num_left(int num[4][4]) {
  int i;
  int j;
  int p;
  int temp;
  for (i = 0; i < 4; i++) {
    for (p = j = 0; j < 4; j++) {
      if (num[i][j] != 0) {
        temp = num[i][j];
        num[i][j] = 0;
        num[i][p] = temp;
        p++;
      }
    }
    for (j = 0; j < 4 - 1; j++) {
      if (num[i][j] == num[i][j + 1]) {
        num[i][j] = num[i][j] * 2;
        num[i][j + 1] = 0;
        j++;
      }
    }
    for (p = j = 0; j < 4; j++) {
      if (num[i][j] != 0) {
        temp = num[i][j];
        num[i][j] = 0;
        num[i][p] = temp;
        p++;
      }
    }
  }
}


x86 assembly (clang, -O0):
<sum_num_left>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jge    1318 <sum_num_left+0x218>
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x10(%rbp)
jge    11b6 <sum_num_left+0xb6>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     11a3 <sum_num_left+0xa3>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a8 <sum_num_left+0xa8>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1127 <sum_num_left+0x27>
movl   $0x0,-0x10(%rbp)
cmpl   $0x3,-0x10(%rbp)
jge    1268 <sum_num_left+0x168>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1255 <sum_num_left+0x155>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x1,%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    125a <sum_num_left+0x15a>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11bd <sum_num_left+0xbd>
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x10(%rbp)
jge    1305 <sum_num_left+0x205>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12f2 <sum_num_left+0x1f2>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12f7 <sum_num_left+0x1f7>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1276 <sum_num_left+0x176>
jmp    130a <sum_num_left+0x20a>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    110f <sum_num_left+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sum_num_left>:
push   %rbx
xor    %r11d,%r11d
jmp    111e <sum_num_left+0x1e>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r11
cmp    $0x4,%r11
je     1244 <sum_num_left+0x144>
mov    %r11,%rax
shl    $0x4,%rax
lea    (%rdi,%rax,1),%rcx
mov    (%rdi,%rax,1),%edx
mov    0x4(%rdi,%rax,1),%r9d
xor    %esi,%esi
test   %edx,%edx
setne  %bl
lea    (%rdi,%rax,1),%r8
add    $0x4,%r8
test   %r9d,%r9d
je     1160 <sum_num_left+0x60>
xor    %esi,%esi
test   %edx,%edx
setne  %sil
movl   $0x0,(%r8)
mov    %r9d,(%rcx,%rsi,4)
add    $0x1,%esi
jmp    1163 <sum_num_left+0x63>
nopl   (%rax)
mov    %bl,%sil
lea    (%rdi,%rax,1),%r10
add    $0x8,%r10
mov    0x8(%rdi,%rax,1),%edx
test   %edx,%edx
je     1182 <sum_num_left+0x82>
movl   $0x0,(%r10)
mov    %esi,%ebx
mov    %edx,(%rcx,%rbx,4)
add    $0x1,%esi
lea    (%rdi,%rax,1),%r9
add    $0xc,%r9
mov    0xc(%rdi,%rax,1),%eax
test   %eax,%eax
je     119e <sum_num_left+0x9e>
movl   $0x0,(%r9)
mov    %esi,%edx
mov    %eax,(%rcx,%rdx,4)
xor    %esi,%esi
jmp    11c9 <sum_num_left+0xc9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rcx,%rax,4),%rsi
add    %ebx,%ebx
mov    %ebx,(%rsi)
movl   $0x0,0x4(%rsi)
add    $0x2,%eax
mov    %eax,%esi
cmp    $0x2,%edx
jge    11e0 <sum_num_left+0xe0>
movslq %esi,%rax
mov    (%rcx,%rax,4),%ebx
lea    0x1(%rax),%edx
cmp    0x4(%rcx,%rax,4),%ebx
je     11b0 <sum_num_left+0xb0>
mov    %edx,%eax
mov    %esi,%edx
jmp    11c2 <sum_num_left+0xc2>
xchg   %ax,%ax
mov    (%rcx),%esi
xor    %eax,%eax
test   %esi,%esi
setne  %bl
mov    (%r8),%edx
test   %edx,%edx
je     1210 <sum_num_left+0x110>
xor    %eax,%eax
test   %esi,%esi
setne  %al
movl   $0x0,(%r8)
mov    %edx,(%rcx,%rax,4)
add    $0x1,%eax
jmp    1212 <sum_num_left+0x112>
cs nopw 0x0(%rax,%rax,1)
mov    %bl,%al
mov    (%r10),%edx
test   %edx,%edx
je     1228 <sum_num_left+0x128>
movl   $0x0,(%r10)
mov    %eax,%esi
mov    %edx,(%rcx,%rsi,4)
add    $0x1,%eax
mov    (%r9),%edx
test   %edx,%edx
je     1110 <sum_num_left+0x10>
movl   $0x0,(%r9)
mov    %eax,%eax
mov    %edx,(%rcx,%rax,4)
jmp    1110 <sum_num_left+0x10>
pop    %rbx
ret

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

LLVM IR (-O2):
define void @sum_num_left([4 x i32]* nocapture %0) {
br label %2
2: ; preds = %1, %75
%3 = phi i64 [ 0, %1 ], [ %76, %75 ]
%4 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 0
%5 = load i32, i32* %4
%6 = icmp ne i32 %5, 0
%7 = zext i1 %6 to i32
%8 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 1
%9 = load i32, i32* %8
%10 = icmp eq i32 %9, 0
br i1 %10, label %15, label %11
11: ; preds = %2
store i32 0, i32* %8
%12 = zext i1 %6 to i64
%13 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 %12
store i32 %9, i32* %13
%14 = select i1 %6, i32 2, i32 1
br label %15
15: ; preds = %11, %2
%16 = phi i32 [ %14, %11 ], [ %7, %2 ]
%17 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 2
%18 = load i32, i32* %17
%19 = icmp eq i32 %18, 0
br i1 %19, label %24, label %20
20: ; preds = %15
store i32 0, i32* %17
%21 = zext i32 %16 to i64
%22 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 %21
store i32 %18, i32* %22
%23 = add nuw nsw i32 %16, 1
br label %24
24: ; preds = %20, %15
%25 = phi i32 [ %23, %20 ], [ %16, %15 ]
%26 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 3
%27 = load i32, i32* %26
%28 = icmp eq i32 %27, 0
br i1 %28, label %29, label %30
29: ; preds = %30, %24
br label %39
30: ; preds = %24
store i32 0, i32* %26
%31 = zext i32 %25 to i64
%32 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 %31
store i32 %27, i32* %32
br label %29
33: ; preds = %52
%34 = load i32, i32* %4
%35 = icmp ne i32 %34, 0
%36 = zext i1 %35 to i32
%37 = load i32, i32* %8
%38 = icmp eq i32 %37, 0
br i1 %38, label %60, label %56
39: ; preds = %29, %52
%40 = phi i32 [ %53, %52 ], [ 0, %29 ]
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 %41
%43 = load i32, i32* %42
%44 = add nsw i32 %40, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 %45
%47 = load i32, i32* %46
%48 = icmp eq i32 %43, %47
br i1 %48, label %49, label %52
49: ; preds = %39
%50 = shl nsw i32 %43, 1
store i32 %50, i32* %42
store i32 0, i32* %46
%51 = add nsw i32 %40, 2
br label %52
52: ; preds = %39, %49
%53 = phi i32 [ %44, %39 ], [ %51, %49 ]
%54 = phi i32 [ %40, %39 ], [ %44, %49 ]
%55 = icmp slt i32 %54, 2
br i1 %55, label %39, label %33
56: ; preds = %33
store i32 0, i32* %8
%57 = zext i1 %35 to i64
%58 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 %57
store i32 %37, i32* %58
%59 = select i1 %35, i32 2, i32 1
br label %60
60: ; preds = %56, %33
%61 = phi i32 [ %59, %56 ], [ %36, %33 ]
%62 = load i32, i32* %17
%63 = icmp eq i32 %62, 0
br i1 %63, label %68, label %64
64: ; preds = %60
store i32 0, i32* %17
%65 = zext i32 %61 to i64
%66 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 %65
store i32 %62, i32* %66
%67 = add nuw nsw i32 %61, 1
br label %68
68: ; preds = %64, %60
%69 = phi i32 [ %67, %64 ], [ %61, %60 ]
%70 = load i32, i32* %26
%71 = icmp eq i32 %70, 0
br i1 %71, label %75, label %72
72: ; preds = %68
store i32 0, i32* %26
%73 = zext i32 %69 to i64
%74 = getelementptr inbounds [4 x i32], [4 x i32]* %0, i64 %3, i64 %73
store i32 %70, i32* %74
br label %75
75: ; preds = %72, %68
%76 = add nuw nsw i64 %3, 1
%77 = icmp eq i64 %76, 4
br i1 %77, label %78, label %2
78: ; preds = %75
ret void
}