int find_missing(int orig[], int On, int shuffled[]) {
  int i, sum = 0;
  for (i = 0; i < On - 1; i++)
    sum += orig[i] - shuffled[i];
  return sum + orig[On - 1];
}


x86 assembly (clang, -O0):
<find_missing>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1158 <find_missing+0x58>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111d <find_missing+0x1d>
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_missing>:
lea    -0x1(%rsi),%r8d
xor    %eax,%eax
cmp    $0x2,%esi
jl     120f <find_missing+0x10f>
mov    %r8d,%r10d
cmp    $0x8,%r8d
jae    1121 <find_missing+0x21>
xor    %esi,%esi
xor    %eax,%eax
jmp    1200 <find_missing+0x100>
mov    %r10d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1216 <find_missing+0x116>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
movdqu (%rdi,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rdi,%rax,4),%xmm3
paddd  %xmm1,%xmm3
movdqu 0x20(%rdi,%rax,4),%xmm0
paddd  %xmm2,%xmm0
movdqu 0x30(%rdi,%rax,4),%xmm1
paddd  %xmm3,%xmm1
movdqu (%rdx,%rax,4),%xmm2
movdqu 0x10(%rdx,%rax,4),%xmm3
movdqu 0x20(%rdx,%rax,4),%xmm4
paddd  %xmm2,%xmm4
psubd  %xmm4,%xmm0
movdqu 0x30(%rdx,%rax,4),%xmm2
paddd  %xmm3,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1150 <find_missing+0x50>
test   $0x1,%r9b
je     11dc <find_missing+0xdc>
movdqu (%rdi,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rdi,%rax,4),%xmm3
paddd  %xmm1,%xmm3
movdqu (%rdx,%rax,4),%xmm0
psubd  %xmm0,%xmm2
movdqu 0x10(%rdx,%rax,4),%xmm0
psubd  %xmm0,%xmm3
movdqa %xmm2,%xmm0
movdqa %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r10,%rsi
je     120f <find_missing+0x10f>
nopl   0x0(%rax,%rax,1)
add    (%rdi,%rsi,4),%eax
sub    (%rdx,%rsi,4),%eax
add    $0x1,%rsi
cmp    %rsi,%r10
jne    1200 <find_missing+0x100>
movslq %r8d,%rcx
add    (%rdi,%rcx,4),%eax
ret
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
test   $0x1,%r9b
jne    11ae <find_missing+0xae>
jmp    11dc <find_missing+0xdc>

LLVM IR (-O0):
define i32 @find_missing(i32* %0, i32 %1, i32* %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32* %2, i32** %6
store i32 0, i32* %8
store i32 0, i32* %7
br label %9
9: ; preds = %28, %3
%10 = load i32, i32* %7
%11 = load i32, i32* %5
%12 = sub nsw i32 %11, 1
%13 = icmp slt i32 %10, %12
br i1 %13, label %14, label %31
14: ; preds = %9
%15 = load i32*, i32** %4
%16 = load i32, i32* %7
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i32, i32* %15, i64 %17
%19 = load i32, i32* %18
%20 = load i32*, i32** %6
%21 = load i32, i32* %7
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %20, i64 %22
%24 = load i32, i32* %23
%25 = sub nsw i32 %19, %24
%26 = load i32, i32* %8
%27 = add nsw i32 %26, %25
store i32 %27, i32* %8
br label %28
28: ; preds = %14
%29 = load i32, i32* %7
%30 = add nsw i32 %29, 1
store i32 %30, i32* %7
br label %9
31: ; preds = %9
%32 = load i32, i32* %8
%33 = load i32*, i32** %4
%34 = load i32, i32* %5
%35 = sub nsw i32 %34, 1
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i32, i32* %33, i64 %36
%38 = load i32, i32* %37
%39 = add nsw i32 %32, %38
ret i32 %39
}

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