void findTwoNotRepeatNumbers(int a[], int n, int *num1, int *num2) {
  int i, j;
  int temp;
  for (i = 0; i < n; i++) {
    temp ^= a[i];
  }
  for (j = 0; j < sizeof(int) * 8; j++)
    if ((temp >> j) & 1 == 1)
      break;
  *num1 = 0;
  *num2 = 0;
  for (i = 0; i < n; i++) {
    if ((a[i] >> j) & 1 == 1)
      *num1 ^= a[i];
    else
      *num2 ^= a[i];
  }
}


x86 assembly (clang, -O0):
<findTwoNotRepeatNumbers>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1145 <findTwoNotRepeatNumbers+0x45>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111a <findTwoNotRepeatNumbers+0x1a>
movl   $0x0,-0x28(%rbp)
movslq -0x28(%rbp),%rax
cmp    $0x20,%rax
jae    1186 <findTwoNotRepeatNumbers+0x86>
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
sar    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1173 <findTwoNotRepeatNumbers+0x73>
jmp    1186 <findTwoNotRepeatNumbers+0x86>
jmp    1178 <findTwoNotRepeatNumbers+0x78>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    114c <findTwoNotRepeatNumbers+0x4c>
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1207 <findTwoNotRepeatNumbers+0x107>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%ecx
sar    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     11e1 <findTwoNotRepeatNumbers+0xe1>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x18(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
jmp    11f4 <findTwoNotRepeatNumbers+0xf4>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x20(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
jmp    11f9 <findTwoNotRepeatNumbers+0xf9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a1 <findTwoNotRepeatNumbers+0xa1>
pop    %rbp
ret

x86 assembly (clang, -O2):
<findTwoNotRepeatNumbers>:
mov    %rcx,%r10
mov    %esi,%r8d
test   %esi,%esi
jle    1116 <findTwoNotRepeatNumbers+0x16>
cmp    $0x8,%esi
jae    111b <findTwoNotRepeatNumbers+0x1b>
xor    %ecx,%ecx
jmp    1210 <findTwoNotRepeatNumbers+0x110>
jmp    121d <findTwoNotRepeatNumbers+0x11d>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1149 <findTwoNotRepeatNumbers+0x49>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
jmp    11b9 <findTwoNotRepeatNumbers+0xb9>
and    $0xfffffffffffffffc,%r11
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu (%rdi,%rax,4),%xmm2
pxor   %xmm0,%xmm2
movdqu 0x10(%rdi,%rax,4),%xmm0
pxor   %xmm1,%xmm0
movdqu 0x20(%rdi,%rax,4),%xmm1
movdqu 0x30(%rdi,%rax,4),%xmm3
movdqu 0x40(%rdi,%rax,4),%xmm4
pxor   %xmm1,%xmm4
pxor   %xmm2,%xmm4
movdqu 0x50(%rdi,%rax,4),%xmm2
pxor   %xmm3,%xmm2
pxor   %xmm0,%xmm2
movdqu 0x60(%rdi,%rax,4),%xmm0
pxor   %xmm4,%xmm0
movdqu 0x70(%rdi,%rax,4),%xmm1
pxor   %xmm2,%xmm1
add    $0x20,%rax
add    $0xfffffffffffffffc,%r11
jne    1160 <findTwoNotRepeatNumbers+0x60>
test   %r9,%r9
je     11ee <findTwoNotRepeatNumbers+0xee>
lea    (%rdi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
nopl   0x0(%rax)
movdqu -0x10(%r11,%rax,1),%xmm2
pxor   %xmm2,%xmm0
movdqu (%r11,%rax,1),%xmm2
pxor   %xmm2,%xmm1
add    $0x20,%rax
cmp    %rax,%r9
jne    11d0 <findTwoNotRepeatNumbers+0xd0>
pxor   %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pxor   %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pxor   %xmm1,%xmm0
movd   %xmm0,%r9d
cmp    %r8,%rcx
je     121d <findTwoNotRepeatNumbers+0x11d>
xchg   %ax,%ax
xor    (%rdi,%rcx,4),%r9d
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1210 <findTwoNotRepeatNumbers+0x110>
xor    %ecx,%ecx
nop
bt     %ecx,%r9d
jb     1266 <findTwoNotRepeatNumbers+0x166>
lea    0x1(%rcx),%eax
movzbl %al,%eax
bt     %eax,%r9d
jb     1259 <findTwoNotRepeatNumbers+0x159>
lea    0x2(%rcx),%eax
movzbl %al,%eax
bt     %eax,%r9d
jb     125e <findTwoNotRepeatNumbers+0x15e>
lea    0x3(%rcx),%eax
movzbl %al,%eax
bt     %eax,%r9d
jb     1263 <findTwoNotRepeatNumbers+0x163>
add    $0x4,%ecx
cmp    $0x20,%ecx
jne    1220 <findTwoNotRepeatNumbers+0x120>
mov    $0x20,%ecx
jmp    1266 <findTwoNotRepeatNumbers+0x166>
add    $0x1,%ecx
jmp    1266 <findTwoNotRepeatNumbers+0x166>
add    $0x2,%ecx
jmp    1266 <findTwoNotRepeatNumbers+0x166>
add    $0x3,%ecx
movl   $0x0,(%rdx)
movl   $0x0,(%r10)
test   %esi,%esi
jle    12da <findTwoNotRepeatNumbers+0x1da>
mov    $0x1,%r11d
shl    %cl,%r11d
cmp    $0x1,%esi
jne    1289 <findTwoNotRepeatNumbers+0x189>
xor    %ecx,%ecx
jmp    12c8 <findTwoNotRepeatNumbers+0x1c8>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%rcx,4),%esi
test   %r11d,%esi
mov    %rdx,%rax
cmove  %r10,%rax
xor    %esi,(%rax)
mov    0x4(%rdi,%rcx,4),%eax
test   %r11d,%eax
mov    %rdx,%rsi
cmove  %r10,%rsi
xor    %eax,(%rsi)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    12a0 <findTwoNotRepeatNumbers+0x1a0>
test   $0x1,%r8b
je     12da <findTwoNotRepeatNumbers+0x1da>
mov    (%rdi,%rcx,4),%eax
test   %r11d,%eax
cmove  %r10,%rdx
xor    %eax,(%rdx)
ret

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

LLVM IR (-O2):
define void @findTwoNotRepeatNumbers(i32* nocapture %0, i32 %1, i32* nocapture %2, i32* nocapture %3) {
%5 = icmp sgt i32 %1, 0
br i1 %5, label %6, label %93
6: ; preds = %4
%7 = zext i32 %1 to i64
%8 = icmp ult i32 %1, 8
br i1 %8, label %90, 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, 3
%15 = icmp ult i64 %11, 24
br i1 %15, label %61, label %16
16: ; preds = %9
%17 = and i64 %13, 4611686018427387900
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %58, %18 ]
%20 = phi <4 x i32> [ <i32 undef, i32 0, i32 0, i32 0>, %16 ], [ %56, %18 ]
%21 = phi <4 x i32> [ zeroinitializer, %16 ], [ %57, %18 ]
%22 = phi i64 [ 0, %16 ], [ %59, %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 = xor <4 x i32> %25, %20
%30 = xor <4 x i32> %28, %21
%31 = or i64 %19, 8
%32 = getelementptr inbounds i32, i32* %0, i64 %31
%33 = bitcast i32* %32 to <4 x i32>*
%34 = load <4 x i32>, <4 x i32>* %33
%35 = getelementptr inbounds i32, i32* %32, i64 4
%36 = bitcast i32* %35 to <4 x i32>*
%37 = load <4 x i32>, <4 x i32>* %36
%38 = xor <4 x i32> %34, %29
%39 = xor <4 x i32> %37, %30
%40 = or i64 %19, 16
%41 = getelementptr inbounds i32, i32* %0, i64 %40
%42 = bitcast i32* %41 to <4 x i32>*
%43 = load <4 x i32>, <4 x i32>* %42
%44 = getelementptr inbounds i32, i32* %41, i64 4
%45 = bitcast i32* %44 to <4 x i32>*
%46 = load <4 x i32>, <4 x i32>* %45
%47 = xor <4 x i32> %43, %38
%48 = xor <4 x i32> %46, %39
%49 = or i64 %19, 24
%50 = getelementptr inbounds i32, i32* %0, i64 %49
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %50, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = xor <4 x i32> %52, %47
%57 = xor <4 x i32> %55, %48
%58 = add nuw i64 %19, 32
%59 = add i64 %22, 4
%60 = icmp eq i64 %59, %17
br i1 %60, label %61, label %18
61: ; preds = %18, %9
%62 = phi <4 x i32> [ undef, %9 ], [ %56, %18 ]
%63 = phi <4 x i32> [ undef, %9 ], [ %57, %18 ]
%64 = phi i64 [ 0, %9 ], [ %58, %18 ]
%65 = phi <4 x i32> [ <i32 undef, i32 0, i32 0, i32 0>, %9 ], [ %56, %18 ]
%66 = phi <4 x i32> [ zeroinitializer, %9 ], [ %57, %18 ]
%67 = icmp eq i64 %14, 0
br i1 %67, label %84, label %68
68: ; preds = %61, %68
%69 = phi i64 [ %81, %68 ], [ %64, %61 ]
%70 = phi <4 x i32> [ %79, %68 ], [ %65, %61 ]
%71 = phi <4 x i32> [ %80, %68 ], [ %66, %61 ]
%72 = phi i64 [ %82, %68 ], [ 0, %61 ]
%73 = getelementptr inbounds i32, i32* %0, i64 %69
%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 = xor <4 x i32> %75, %70
%80 = xor <4 x i32> %78, %71
%81 = add nuw i64 %69, 8
%82 = add i64 %72, 1
%83 = icmp eq i64 %82, %14
br i1 %83, label %84, label %68
84: ; preds = %68, %61
%85 = phi <4 x i32> [ %62, %61 ], [ %79, %68 ]
%86 = phi <4 x i32> [ %63, %61 ], [ %80, %68 ]
%87 = xor <4 x i32> %86, %85
%88 = call i32 @llvm.vector.reduce.xor.v4i32(<4 x i32> %87)
%89 = icmp eq i64 %10, %7
br i1 %89, label %93, label %90
90: ; preds = %6, %84
%91 = phi i64 [ 0, %6 ], [ %10, %84 ]
%92 = phi i32 [ undef, %6 ], [ %88, %84 ]
br label %95
93: ; preds = %95, %84, %4
%94 = phi i32 [ undef, %4 ], [ %88, %84 ], [ %100, %95 ]
br label %103
95: ; preds = %90, %95
%96 = phi i64 [ %101, %95 ], [ %91, %90 ]
%97 = phi i32 [ %100, %95 ], [ %92, %90 ]
%98 = getelementptr inbounds i32, i32* %0, i64 %96
%99 = load i32, i32* %98
%100 = xor i32 %99, %97
%101 = add nuw nsw i64 %96, 1
%102 = icmp eq i64 %101, %7
br i1 %102, label %93, label %95
103: ; preds = %123, %93
%104 = phi i32 [ 0, %93 ], [ %124, %123 ]
%105 = shl nuw i32 1, %104
%106 = and i32 %105, %94
%107 = icmp eq i32 %106, 0
br i1 %107, label %108, label %126
108: ; preds = %103
%109 = or i32 %104, 1
%110 = shl nuw i32 1, %109
%111 = and i32 %110, %94
%112 = icmp eq i32 %111, 0
br i1 %112, label %113, label %126
113: ; preds = %108
%114 = or i32 %104, 2
%115 = shl nuw i32 1, %114
%116 = and i32 %115, %94
%117 = icmp eq i32 %116, 0
br i1 %117, label %118, label %126
118: ; preds = %113
%119 = or i32 %104, 3
%120 = shl nuw i32 1, %119
%121 = and i32 %120, %94
%122 = icmp eq i32 %121, 0
br i1 %122, label %123, label %126
123: ; preds = %118
%124 = add nuw nsw i32 %104, 4
%125 = icmp eq i32 %124, 32
br i1 %125, label %126, label %103
126: ; preds = %123, %118, %113, %108, %103
%127 = phi i32 [ %104, %103 ], [ %109, %108 ], [ %114, %113 ], [ %119, %118 ], [ 32, %123 ]
store i32 0, i32* %2
store i32 0, i32* %3
br i1 %5, label %128, label %167
128: ; preds = %126
%129 = shl nuw i32 1, %127
%130 = zext i32 %1 to i64
%131 = and i64 %130, 1
%132 = icmp eq i32 %1, 1
br i1 %132, label %156, label %133
133: ; preds = %128
%134 = and i64 %130, 4294967294
br label %135
135: ; preds = %135, %133
%136 = phi i64 [ 0, %133 ], [ %153, %135 ]
%137 = phi i64 [ 0, %133 ], [ %154, %135 ]
%138 = getelementptr inbounds i32, i32* %0, i64 %136
%139 = load i32, i32* %138
%140 = and i32 %139, %129
%141 = icmp eq i32 %140, 0
%142 = select i1 %141, i32* %3, i32* %2
%143 = load i32, i32* %142
%144 = xor i32 %143, %139
store i32 %144, i32* %142
%145 = or i64 %136, 1
%146 = getelementptr inbounds i32, i32* %0, i64 %145
%147 = load i32, i32* %146
%148 = and i32 %147, %129
%149 = icmp eq i32 %148, 0
%150 = select i1 %149, i32* %3, i32* %2
%151 = load i32, i32* %150
%152 = xor i32 %151, %147
store i32 %152, i32* %150
%153 = add nuw nsw i64 %136, 2
%154 = add i64 %137, 2
%155 = icmp eq i64 %154, %134
br i1 %155, label %156, label %135
156: ; preds = %135, %128
%157 = phi i64 [ 0, %128 ], [ %153, %135 ]
%158 = icmp eq i64 %131, 0
br i1 %158, label %167, label %159
159: ; preds = %156
%160 = getelementptr inbounds i32, i32* %0, i64 %157
%161 = load i32, i32* %160
%162 = and i32 %161, %129
%163 = icmp eq i32 %162, 0
%164 = select i1 %163, i32* %3, i32* %2
%165 = load i32, i32* %164
%166 = xor i32 %165, %161
store i32 %166, i32* %164
br label %167
167: ; preds = %159, %156, %126
ret void
}