int missingNumber(int *nums, int numsSize) {
  int r = 0;
  while (numsSize--)
    r += numsSize + 1 - nums[numsSize];
  return r;
}


x86 assembly (clang, -O0):
<missingNumber>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
cmp    $0x0,%eax
je     1142 <missingNumber+0x42>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    1112 <missingNumber+0x12>
mov    -0x10(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<missingNumber>:
test   %esi,%esi
je     125a <missingNumber+0x15a>
movslq %esi,%rcx
lea    -0x1(%rsi),%r9d
xor    %eax,%eax
cmp    $0x7,%r9d
jb     1240 <missingNumber+0x140>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xec9(%rip),%xmm0
lea    -0x8(%r8),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     125d <missingNumber+0x15d>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%rcx,4),%rdx
add    $0xfffffffffffffff0,%rdx
pxor   %xmm1,%xmm1
mov    $0xfffffffffffffffc,%rsi
movdqa 0xe9f(%rip),%xmm3
movdqa 0xea7(%rip),%xmm4
pxor   %xmm2,%xmm2
nopl   (%rax)
paddd  %xmm0,%xmm2
movdqu -0x20(%rdx,%rsi,4),%xmm5
movdqu -0x10(%rdx,%rsi,4),%xmm6
movdqu (%rdx,%rsi,4),%xmm7
paddd  %xmm5,%xmm7
movdqu 0x10(%rdx,%rsi,4),%xmm5
paddd  %xmm6,%xmm5
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
paddd  %xmm0,%xmm1
pshufd $0x1b,%xmm5,%xmm5
psubd  %xmm5,%xmm1
paddd  %xmm3,%xmm1
pshufd $0x1b,%xmm7,%xmm5
psubd  %xmm5,%xmm2
paddd  %xmm4,%xmm2
paddd  %xmm4,%xmm0
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%rax
jne    1180 <missingNumber+0x80>
add    $0x3,%rsi
test   $0x1,%r10b
je     1212 <missingNumber+0x112>
paddd  %xmm0,%xmm2
add    %rcx,%rsi
movdqu -0x1c(%rdi,%rsi,4),%xmm3
movdqu -0xc(%rdi,%rsi,4),%xmm4
pshufd $0x1b,%xmm4,%xmm4
pshufd $0x1b,%xmm3,%xmm3
psubd  %xmm3,%xmm2
paddd  %xmm0,%xmm1
psubd  %xmm4,%xmm1
paddd  0xe1e(%rip),%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
cmp    %r8,%r9
je     1259 <missingNumber+0x159>
sub    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%edx
mov    %rcx,%rax
add    $0xffffffffffffffff,%rcx
sub    -0x4(%rdi,%rax,4),%edx
add    %edx,%eax
test   %ecx,%ecx
jne    1240 <missingNumber+0x140>
lea    (%rdx,%rcx,1),%eax
add    $0x1,%eax
ret
xor    %eax,%eax
ret
pxor   %xmm1,%xmm1
mov    $0xffffffffffffffff,%rsi
pxor   %xmm2,%xmm2
test   $0x1,%r10b
jne    11e1 <missingNumber+0xe1>
jmp    1212 <missingNumber+0x112>

LLVM IR (-O0):
define i32 @missingNumber(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32
store i32* %0, i32** %3
store i32 %1, i32* %4
store i32 0, i32* %5
br label %6
6: ; preds = %10, %2
%7 = load i32, i32* %4
%8 = add nsw i32 %7, -1
store i32 %8, i32* %4
%9 = icmp ne i32 %7, 0
br i1 %9, label %10, label %21
10: ; preds = %6
%11 = load i32, i32* %4
%12 = add nsw i32 %11, 1
%13 = load i32*, i32** %3
%14 = load i32, i32* %4
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i32, i32* %13, i64 %15
%17 = load i32, i32* %16
%18 = sub nsw i32 %12, %17
%19 = load i32, i32* %5
%20 = add nsw i32 %19, %18
store i32 %20, i32* %5
br label %6
21: ; preds = %6
%22 = load i32, i32* %5
ret i32 %22
}

LLVM IR (-O2):
define i32 @missingNumber(i32* nocapture %0, i32 %1) {
%3 = icmp eq i32 %1, 0
br i1 %3, label %113, label %4
4: ; preds = %2
%5 = sext i32 %1 to i64
%6 = add i32 %1, -1
%7 = zext i32 %6 to i64
%8 = add nuw nsw i64 %7, 1
%9 = icmp ult i32 %6, 7
br i1 %9, label %99, label %10
10: ; preds = %4
%11 = and i64 %8, 8589934584
%12 = sub nsw i64 %5, %11
%13 = insertelement <4 x i32> poison, i32 %1, i64 0
%14 = shufflevector <4 x i32> %13, <4 x i32> poison, <4 x i32> zeroinitializer
%15 = add <4 x i32> %14, <i32 0, i32 -1, i32 -2, i32 -3>
%16 = add nsw i64 %11, -8
%17 = lshr exact i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 1
%20 = icmp eq i64 %16, 0
br i1 %20, label %68, label %21
21: ; preds = %10
%22 = and i64 %18, 4611686018427387902
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %62, %23 ]
%25 = phi <4 x i32> [ zeroinitializer, %21 ], [ %57, %23 ]
%26 = phi <4 x i32> [ zeroinitializer, %21 ], [ %61, %23 ]
%27 = phi <4 x i32> [ %15, %21 ], [ %63, %23 ]
%28 = phi i64 [ 0, %21 ], [ %64, %23 ]
%29 = add <4 x i32> %27, <i32 -4, i32 -4, i32 -4, i32 -4>
%30 = xor i64 %24, -1
%31 = add i64 %30, %5
%32 = getelementptr inbounds i32, i32* %0, i64 %31
%33 = getelementptr inbounds i32, i32* %32, i64 -3
%34 = bitcast i32* %33 to <4 x i32>*
%35 = load <4 x i32>, <4 x i32>* %34
%36 = getelementptr inbounds i32, i32* %32, i64 -4
%37 = getelementptr inbounds i32, i32* %36, i64 -3
%38 = bitcast i32* %37 to <4 x i32>*
%39 = load <4 x i32>, <4 x i32>* %38
%40 = add <4 x i32> %25, %27
%41 = add <4 x i32> %26, %29
%42 = add <4 x i32> %27, <i32 -8, i32 -8, i32 -8, i32 -8>
%43 = add <4 x i32> %27, <i32 -12, i32 -12, i32 -12, i32 -12>
%44 = sub nuw nsw i64 -9, %24
%45 = add i64 %44, %5
%46 = getelementptr inbounds i32, i32* %0, i64 %45
%47 = getelementptr inbounds i32, i32* %46, i64 -3
%48 = bitcast i32* %47 to <4 x i32>*
%49 = load <4 x i32>, <4 x i32>* %48
%50 = getelementptr inbounds i32, i32* %46, i64 -4
%51 = getelementptr inbounds i32, i32* %50, i64 -3
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = add <4 x i32> %40, %42
%55 = add <4 x i32> %35, %49
%56 = shufflevector <4 x i32> %55, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%57 = sub <4 x i32> %54, %56
%58 = add <4 x i32> %41, %43
%59 = add <4 x i32> %39, %53
%60 = shufflevector <4 x i32> %59, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%61 = sub <4 x i32> %58, %60
%62 = add nuw i64 %24, 16
%63 = add <4 x i32> %27, <i32 -16, i32 -16, i32 -16, i32 -16>
%64 = add i64 %28, 2
%65 = icmp eq i64 %64, %22
br i1 %65, label %66, label %23
66: ; preds = %23
%67 = sub i64 -17, %24
br label %68
68: ; preds = %66, %10
%69 = phi <4 x i32> [ undef, %10 ], [ %57, %66 ]
%70 = phi <4 x i32> [ undef, %10 ], [ %61, %66 ]
%71 = phi i64 [ -1, %10 ], [ %67, %66 ]
%72 = phi <4 x i32> [ zeroinitializer, %10 ], [ %57, %66 ]
%73 = phi <4 x i32> [ zeroinitializer, %10 ], [ %61, %66 ]
%74 = phi <4 x i32> [ %15, %10 ], [ %63, %66 ]
%75 = icmp eq i64 %19, 0
br i1 %75, label %93, label %76
76: ; preds = %68
%77 = add <4 x i32> %74, <i32 -4, i32 -4, i32 -4, i32 -4>
%78 = add i64 %71, %5
%79 = getelementptr inbounds i32, i32* %0, i64 %78
%80 = getelementptr inbounds i32, i32* %79, i64 -3
%81 = bitcast i32* %80 to <4 x i32>*
%82 = load <4 x i32>, <4 x i32>* %81
%83 = shufflevector <4 x i32> %82, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%84 = getelementptr inbounds i32, i32* %79, i64 -4
%85 = getelementptr inbounds i32, i32* %84, i64 -3
%86 = bitcast i32* %85 to <4 x i32>*
%87 = load <4 x i32>, <4 x i32>* %86
%88 = shufflevector <4 x i32> %87, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%89 = add <4 x i32> %72, %74
%90 = add <4 x i32> %73, %77
%91 = sub <4 x i32> %89, %83
%92 = sub <4 x i32> %90, %88
br label %93
93: ; preds = %68, %76
%94 = phi <4 x i32> [ %69, %68 ], [ %91, %76 ]
%95 = phi <4 x i32> [ %70, %68 ], [ %92, %76 ]
%96 = add <4 x i32> %95, %94
%97 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %96)
%98 = icmp eq i64 %8, %11
br i1 %98, label %113, label %99
99: ; preds = %4, %93
%100 = phi i64 [ %5, %4 ], [ %12, %93 ]
%101 = phi i32 [ 0, %4 ], [ %97, %93 ]
br label %102
102: ; preds = %99, %102
%103 = phi i64 [ %105, %102 ], [ %100, %99 ]
%104 = phi i32 [ %110, %102 ], [ %101, %99 ]
%105 = add nsw i64 %103, -1
%106 = getelementptr inbounds i32, i32* %0, i64 %105
%107 = load i32, i32* %106
%108 = trunc i64 %103 to i32
%109 = add i32 %104, %108
%110 = sub i32 %109, %107
%111 = trunc i64 %105 to i32
%112 = icmp eq i32 %111, 0
br i1 %112, label %113, label %102
113: ; preds = %102, %93, %2
%114 = phi i32 [ 0, %2 ], [ %97, %93 ], [ %110, %102 ]
ret i32 %114
}