double findMedianSortedArrays(int A[], int m, int B[], int n) {
  int ai = 0, aj = m - 1, bi = 0, bj = n - 1, a_rest = m, b_rest = n,
      delete_min = (1), *k1, *k2;
  int small = m && A[0] < B[0] ? A[0] : B[0],
      large = m && A[aj] > B[bj] ? A[aj] : B[bj], *c;
  while (a_rest + b_rest > ((m + n) % 2 == 1 ? 1 : 2)) {
    k1 = delete_min ? &ai : &aj;
    k2 = delete_min ? &bi : &bj;
    c = delete_min ? &small : &large;
    if (ai <= aj && bi <= bj &&
            (delete_min ? A[*k1] < B[*k2] : A[*k1] > B[*k2]) ||
        bi > bj) {
      *k1 += delete_min ? 1 : -1;
      a_rest--;
    } else {
      *k2 += delete_min ? 1 : -1;
      b_rest--;
    }
    if (ai <= aj && bi <= bj) {
      *c = (delete_min ? A[*k1] < B[*k2] : A[*k1] > B[*k2]) ? A[*k1] : B[*k2];
    } else if (ai <= aj) {
      *c = delete_min ? A[ai] : A[aj];
    } else {
      *c = delete_min ? B[bi] : B[bj];
    }
    delete_min = !delete_min;
  }
  return (small + large) / 2.;
}


x86 assembly (clang, -O0):
<findMedianSortedArrays>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x38(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     1173 <findMedianSortedArrays+0x73>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1173 <findMedianSortedArrays+0x73>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
jmp    117c <findMedianSortedArrays+0x7c>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     11bb <findMedianSortedArrays+0xbb>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    11bb <findMedianSortedArrays+0xbb>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    11c9 <findMedianSortedArrays+0xc9>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x64(%rbp),%eax
mov    %edx,%esi
mov    $0x2,%ecx
mov    $0x1,%edx
cmp    $0x1,%esi
cmove  %edx,%ecx
cmp    %ecx,%eax
jle    149a <findMedianSortedArrays+0x39a>
cmpl   $0x0,-0x38(%rbp)
je     121a <findMedianSortedArrays+0x11a>
lea    -0x20(%rbp),%rax
mov    %rax,-0x70(%rbp)
jmp    1227 <findMedianSortedArrays+0x127>
lea    -0x24(%rbp),%rax
mov    %rax,-0x70(%rbp)
jmp    1227 <findMedianSortedArrays+0x127>
mov    -0x70(%rbp),%rax
mov    %rax,-0x40(%rbp)
cmpl   $0x0,-0x38(%rbp)
je     1246 <findMedianSortedArrays+0x146>
lea    -0x28(%rbp),%rax
mov    %rax,-0x78(%rbp)
jmp    1253 <findMedianSortedArrays+0x153>
lea    -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
jmp    1253 <findMedianSortedArrays+0x153>
mov    -0x78(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x0,-0x38(%rbp)
je     1272 <findMedianSortedArrays+0x172>
lea    -0x4c(%rbp),%rax
mov    %rax,-0x80(%rbp)
jmp    127f <findMedianSortedArrays+0x17f>
lea    -0x50(%rbp),%rax
mov    %rax,-0x80(%rbp)
jmp    127f <findMedianSortedArrays+0x17f>
mov    -0x80(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     12f2 <findMedianSortedArrays+0x1f2>
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     12f2 <findMedianSortedArrays+0x1f2>
cmpl   $0x0,-0x38(%rbp)
je     12d0 <findMedianSortedArrays+0x1d0>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%rdx
movslq (%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     12fe <findMedianSortedArrays+0x1fe>
jmp    12f2 <findMedianSortedArrays+0x1f2>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%rdx
movslq (%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     12fe <findMedianSortedArrays+0x1fe>
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    1327 <findMedianSortedArrays+0x227>
mov    -0x38(%rbp),%edx
mov    $0xffffffff,%ecx
mov    $0x1,%eax
cmp    $0x0,%edx
cmovne %eax,%ecx
mov    -0x40(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    134b <findMedianSortedArrays+0x24b>
mov    -0x38(%rbp),%edx
mov    $0xffffffff,%ecx
mov    $0x1,%eax
cmp    $0x0,%edx
cmovne %eax,%ecx
mov    -0x48(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     13f4 <findMedianSortedArrays+0x2f4>
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     13f4 <findMedianSortedArrays+0x2f4>
cmpl   $0x0,-0x38(%rbp)
je     1394 <findMedianSortedArrays+0x294>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%rdx
movslq (%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     13b6 <findMedianSortedArrays+0x2b6>
jmp    13cf <findMedianSortedArrays+0x2cf>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%rdx
movslq (%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    13cf <findMedianSortedArrays+0x2cf>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
jmp    13e3 <findMedianSortedArrays+0x2e3>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%ecx
mov    -0x58(%rbp),%rax
mov    %ecx,(%rax)
jmp    1484 <findMedianSortedArrays+0x384>
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1442 <findMedianSortedArrays+0x342>
cmpl   $0x0,-0x38(%rbp)
je     1420 <findMedianSortedArrays+0x320>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
jmp    1431 <findMedianSortedArrays+0x331>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%ecx
mov    -0x58(%rbp),%rax
mov    %ecx,(%rax)
jmp    147f <findMedianSortedArrays+0x37f>
cmpl   $0x0,-0x38(%rbp)
je     1462 <findMedianSortedArrays+0x362>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
jmp    1473 <findMedianSortedArrays+0x373>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%ecx
mov    -0x58(%rbp),%rax
mov    %ecx,(%rax)
jmp    1484 <findMedianSortedArrays+0x384>
cmpl   $0x0,-0x38(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x38(%rbp)
jmp    11cf <findMedianSortedArrays+0xcf>
mov    -0x4c(%rbp),%eax
add    -0x50(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0xb54(%rip),%xmm1
divsd  %xmm1,%xmm0
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<findMedianSortedArrays>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movl   $0x0,-0x1c(%rsp)
lea    -0x1(%rcx),%ebx
mov    %esi,%r9d
movl   $0x0,-0x28(%rsp)
mov    %ebx,-0x2c(%rsp)
sub    $0x1,%r9d
mov    %r9d,-0x20(%rsp)
mov    %rdx,-0x18(%rsp)
mov    %rdi,-0x10(%rsp)
jae    1149 <findMedianSortedArrays+0x49>
mov    (%rdx),%r10d
mov    %r10d,-0x30(%rsp)
movslq %ebx,%rax
mov    (%rdx,%rax,4),%ebx
jmp    1178 <findMedianSortedArrays+0x78>
mov    (%rdi),%r10d
mov    (%rdx),%eax
cmp    %eax,%r10d
jge    115a <findMedianSortedArrays+0x5a>
mov    %r10d,-0x30(%rsp)
jmp    1161 <findMedianSortedArrays+0x61>
mov    %eax,-0x30(%rsp)
mov    %eax,%r10d
movslq %r9d,%rax
mov    (%rdi,%rax,4),%r8d
movslq %ebx,%rax
mov    -0x18(%rsp),%rdx
mov    (%rdx,%rax,4),%ebx
cmp    %ebx,%r8d
jg     117b <findMedianSortedArrays+0x7b>
mov    %ebx,%r8d
mov    %r8d,-0x24(%rsp)
lea    (%rcx,%rsi,1),%ebx
mov    %ebx,%edi
shr    $0x1f,%edi
add    %ebx,%edi
and    $0xfffffffe,%edi
mov    %ebx,%eax
sub    %edi,%eax
xor    %ebp,%ebp
cmp    $0x1,%eax
sete   %bpl
mov    $0x2,%eax
sub    %ebp,%eax
mov    %eax,-0x4(%rsp)
cmp    %eax,%ebx
jle    1309 <findMedianSortedArrays+0x209>
mov    $0x1,%eax
xor    %r13d,%r13d
mov    -0x18(%rsp),%rdx
mov    -0x10(%rsp),%r8
jmp    11e9 <findMedianSortedArrays+0xe9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq (%r12),%rdi
mov    (%rdx,%rdi,4),%ebp
mov    %ebp,(%rbx)
xor    $0x1,%eax
lea    (%rsi,%rcx,1),%edi
cmp    -0x4(%rsp),%edi
jle    12ff <findMedianSortedArrays+0x1ff>
test   %eax,%eax
lea    -0x1c(%rsp),%r11
lea    -0x20(%rsp),%rdi
cmove  %rdi,%r11
lea    -0x28(%rsp),%r12
lea    -0x2c(%rsp),%rdi
cmove  %rdi,%r12
lea    -0x30(%rsp),%rbx
lea    -0x24(%rsp),%rdi
cmove  %rdi,%rbx
mov    -0x28(%rsp),%r14d
mov    -0x2c(%rsp),%r15d
cmp    %r9d,%r13d
jg     1260 <findMedianSortedArrays+0x160>
cmp    %r15d,%r14d
jg     1260 <findMedianSortedArrays+0x160>
movslq (%r11),%r10
mov    (%r8,%r10,4),%ebp
movslq (%r12),%rdi
mov    (%rdx,%rdi,4),%r8d
test   %eax,%eax
je     124d <findMedianSortedArrays+0x14d>
cmp    %r8d,%ebp
mov    -0x18(%rsp),%rdx
mov    -0x10(%rsp),%r8
jge    1260 <findMedianSortedArrays+0x160>
jmp    1268 <findMedianSortedArrays+0x168>
cmp    %r8d,%ebp
mov    -0x18(%rsp),%rdx
mov    -0x10(%rsp),%r8
jg     1268 <findMedianSortedArrays+0x168>
nopl   0x0(%rax)
cmp    %r15d,%r14d
jle    1290 <findMedianSortedArrays+0x190>
mov    (%r11),%r10d
cmp    $0x1,%eax
sbb    %edi,%edi
or     $0x1,%edi
add    %r10d,%edi
mov    %edi,(%r11)
add    $0xffffffff,%esi
mov    -0x1c(%rsp),%r13d
mov    -0x20(%rsp),%r9d
cmp    %r9d,%r13d
jg     11d0 <findMedianSortedArrays+0xd0>
jmp    12a8 <findMedianSortedArrays+0x1a8>
xchg   %ax,%ax
cmp    $0x1,%eax
sbb    %edi,%edi
or     $0x1,%edi
add    %edi,(%r12)
add    $0xffffffff,%ecx
cmp    %r9d,%r13d
jg     11d0 <findMedianSortedArrays+0xd0>
mov    -0x28(%rsp),%edi
cmp    -0x2c(%rsp),%edi
jle    12d0 <findMedianSortedArrays+0x1d0>
test   %eax,%eax
mov    %r13d,%edi
cmove  %r9d,%edi
movslq %edi,%rdi
mov    (%r8,%rdi,4),%ebp
jmp    11d7 <findMedianSortedArrays+0xd7>
nopw   0x0(%rax,%rax,1)
movslq (%r11),%rdi
mov    (%r8,%rdi,4),%ebp
movslq (%r12),%rdi
mov    (%rdx,%rdi,4),%r10d
test   %eax,%eax
je     12ee <findMedianSortedArrays+0x1ee>
cmp    %r10d,%ebp
jl     11d7 <findMedianSortedArrays+0xd7>
jmp    12f7 <findMedianSortedArrays+0x1f7>
cmp    %r10d,%ebp
jg     11d7 <findMedianSortedArrays+0xd7>
mov    %r10d,%ebp
jmp    11d7 <findMedianSortedArrays+0xd7>
mov    -0x30(%rsp),%r10d
mov    -0x24(%rsp),%r8d
add    %r10d,%r8d
cvtsi2sd %r8d,%xmm0
mulsd  0xce7(%rip),%xmm0
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @findMedianSortedArrays(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
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32
%19 = alloca i32
%20 = 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
%21 = load i32, i32* %6
%22 = sub nsw i32 %21, 1
store i32 %22, i32* %10
store i32 0, i32* %11
%23 = load i32, i32* %8
%24 = sub nsw i32 %23, 1
store i32 %24, i32* %12
%25 = load i32, i32* %6
store i32 %25, i32* %13
%26 = load i32, i32* %8
store i32 %26, i32* %14
store i32 1, i32* %15
%27 = load i32, i32* %6
%28 = icmp ne i32 %27, 0
br i1 %28, label %29, label %41
29: ; preds = %4
%30 = load i32*, i32** %5
%31 = getelementptr inbounds i32, i32* %30, i64 0
%32 = load i32, i32* %31
%33 = load i32*, i32** %7
%34 = getelementptr inbounds i32, i32* %33, i64 0
%35 = load i32, i32* %34
%36 = icmp slt i32 %32, %35
br i1 %36, label %37, label %41
37: ; preds = %29
%38 = load i32*, i32** %5
%39 = getelementptr inbounds i32, i32* %38, i64 0
%40 = load i32, i32* %39
br label %45
41: ; preds = %29, %4
%42 = load i32*, i32** %7
%43 = getelementptr inbounds i32, i32* %42, i64 0
%44 = load i32, i32* %43
br label %45
45: ; preds = %41, %37
%46 = phi i32 [ %40, %37 ], [ %44, %41 ]
store i32 %46, i32* %18
%47 = load i32, i32* %6
%48 = icmp ne i32 %47, 0
br i1 %48, label %49, label %67
49: ; preds = %45
%50 = load i32*, i32** %5
%51 = load i32, i32* %10
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i32, i32* %50, i64 %52
%54 = load i32, i32* %53
%55 = load i32*, i32** %7
%56 = load i32, i32* %12
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
%59 = load i32, i32* %58
%60 = icmp sgt i32 %54, %59
br i1 %60, label %61, label %67
61: ; preds = %49
%62 = load i32*, i32** %5
%63 = load i32, i32* %10
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %62, i64 %64
%66 = load i32, i32* %65
br label %73
67: ; preds = %49, %45
%68 = load i32*, i32** %7
%69 = load i32, i32* %12
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i32, i32* %68, i64 %70
%72 = load i32, i32* %71
br label %73
73: ; preds = %67, %61
%74 = phi i32 [ %66, %61 ], [ %72, %67 ]
store i32 %74, i32* %19
br label %75
75: ; preds = %265, %73
%76 = load i32, i32* %13
%77 = load i32, i32* %14
%78 = add nsw i32 %76, %77
%79 = load i32, i32* %6
%80 = load i32, i32* %8
%81 = add nsw i32 %79, %80
%82 = srem i32 %81, 2
%83 = icmp eq i32 %82, 1
%84 = zext i1 %83 to i64
%85 = select i1 %83, i32 1, i32 2
%86 = icmp sgt i32 %78, %85
br i1 %86, label %87, label %270
87: ; preds = %75
%88 = load i32, i32* %15
%89 = icmp ne i32 %88, 0
br i1 %89, label %90, label %91
90: ; preds = %87
br label %92
91: ; preds = %87
br label %92
92: ; preds = %91, %90
%93 = phi i32* [ %9, %90 ], [ %10, %91 ]
store i32* %93, i32** %16
%94 = load i32, i32* %15
%95 = icmp ne i32 %94, 0
br i1 %95, label %96, label %97
96: ; preds = %92
br label %98
97: ; preds = %92
br label %98
98: ; preds = %97, %96
%99 = phi i32* [ %11, %96 ], [ %12, %97 ]
store i32* %99, i32** %17
%100 = load i32, i32* %15
%101 = icmp ne i32 %100, 0
br i1 %101, label %102, label %103
102: ; preds = %98
br label %104
103: ; preds = %98
br label %104
104: ; preds = %103, %102
%105 = phi i32* [ %18, %102 ], [ %19, %103 ]
store i32* %105, i32** %20
%106 = load i32, i32* %9
%107 = load i32, i32* %10
%108 = icmp sle i32 %106, %107
br i1 %108, label %109, label %144
109: ; preds = %104
%110 = load i32, i32* %11
%111 = load i32, i32* %12
%112 = icmp sle i32 %110, %111
br i1 %112, label %113, label %144
113: ; preds = %109
%114 = load i32, i32* %15
%115 = icmp ne i32 %114, 0
br i1 %115, label %116, label %130
116: ; preds = %113
%117 = load i32*, i32** %5
%118 = load i32*, i32** %16
%119 = load i32, i32* %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32, i32* %117, i64 %120
%122 = load i32, i32* %121
%123 = load i32*, i32** %7
%124 = load i32*, i32** %17
%125 = load i32, i32* %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %123, i64 %126
%128 = load i32, i32* %127
%129 = icmp slt i32 %122, %128
br i1 %129, label %148, label %144
130: ; preds = %113
%131 = load i32*, i32** %5
%132 = load i32*, i32** %16
%133 = load i32, i32* %132
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %131, i64 %134
%136 = load i32, i32* %135
%137 = load i32*, i32** %7
%138 = load i32*, i32** %17
%139 = load i32, i32* %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i32, i32* %137, i64 %140
%142 = load i32, i32* %141
%143 = icmp sgt i32 %136, %142
br i1 %143, label %148, label %144
144: ; preds = %130, %116, %109, %104
%145 = load i32, i32* %11
%146 = load i32, i32* %12
%147 = icmp sgt i32 %145, %146
br i1 %147, label %148, label %158
148: ; preds = %144, %130, %116
%149 = load i32, i32* %15
%150 = icmp ne i32 %149, 0
%151 = zext i1 %150 to i64
%152 = select i1 %150, i32 1, i32 -1
%153 = load i32*, i32** %16
%154 = load i32, i32* %153
%155 = add nsw i32 %154, %152
store i32 %155, i32* %153
%156 = load i32, i32* %13
%157 = add nsw i32 %156, -1
store i32 %157, i32* %13
br label %168
158: ; preds = %144
%159 = load i32, i32* %15
%160 = icmp ne i32 %159, 0
%161 = zext i1 %160 to i64
%162 = select i1 %160, i32 1, i32 -1
%163 = load i32*, i32** %17
%164 = load i32, i32* %163
%165 = add nsw i32 %164, %162
store i32 %165, i32* %163
%166 = load i32, i32* %14
%167 = add nsw i32 %166, -1
store i32 %167, i32* %14
br label %168
168: ; preds = %158, %148
%169 = load i32, i32* %9
%170 = load i32, i32* %10
%171 = icmp sle i32 %169, %170
br i1 %171, label %172, label %224
172: ; preds = %168
%173 = load i32, i32* %11
%174 = load i32, i32* %12
%175 = icmp sle i32 %173, %174
br i1 %175, label %176, label %224
176: ; preds = %172
%177 = load i32, i32* %15
%178 = icmp ne i32 %177, 0
br i1 %178, label %179, label %193
179: ; preds = %176
%180 = load i32*, i32** %5
%181 = load i32*, i32** %16
%182 = load i32, i32* %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i32, i32* %180, i64 %183
%185 = load i32, i32* %184
%186 = load i32*, i32** %7
%187 = load i32*, i32** %17
%188 = load i32, i32* %187
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds i32, i32* %186, i64 %189
%191 = load i32, i32* %190
%192 = icmp slt i32 %185, %191
br i1 %192, label %207, label %214
193: ; preds = %176
%194 = load i32*, i32** %5
%195 = load i32*, i32** %16
%196 = load i32, i32* %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %194, i64 %197
%199 = load i32, i32* %198
%200 = load i32*, i32** %7
%201 = load i32*, i32** %17
%202 = load i32, i32* %201
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i32, i32* %200, i64 %203
%205 = load i32, i32* %204
%206 = icmp sgt i32 %199, %205
br i1 %206, label %207, label %214
207: ; preds = %193, %179
%208 = load i32*, i32** %5
%209 = load i32*, i32** %16
%210 = load i32, i32* %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i32, i32* %208, i64 %211
%213 = load i32, i32* %212
br label %221
214: ; preds = %193, %179
%215 = load i32*, i32** %7
%216 = load i32*, i32** %17
%217 = load i32, i32* %216
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i32, i32* %215, i64 %218
%220 = load i32, i32* %219
br label %221
221: ; preds = %214, %207
%222 = phi i32 [ %213, %207 ], [ %220, %214 ]
%223 = load i32*, i32** %20
store i32 %222, i32* %223
br label %265
224: ; preds = %172, %168
%225 = load i32, i32* %9
%226 = load i32, i32* %10
%227 = icmp sle i32 %225, %226
br i1 %227, label %228, label %246
228: ; preds = %224
%229 = load i32, i32* %15
%230 = icmp ne i32 %229, 0
br i1 %230, label %231, label %237
231: ; preds = %228
%232 = load i32*, i32** %5
%233 = load i32, i32* %9
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %232, i64 %234
%236 = load i32, i32* %235
br label %243
237: ; preds = %228
%238 = load i32*, i32** %5
%239 = load i32, i32* %10
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i32, i32* %238, i64 %240
%242 = load i32, i32* %241
br label %243
243: ; preds = %237, %231
%244 = phi i32 [ %236, %231 ], [ %242, %237 ]
%245 = load i32*, i32** %20
store i32 %244, i32* %245
br label %264
246: ; preds = %224
%247 = load i32, i32* %15
%248 = icmp ne i32 %247, 0
br i1 %248, label %249, label %255
249: ; preds = %246
%250 = load i32*, i32** %7
%251 = load i32, i32* %11
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i32, i32* %250, i64 %252
%254 = load i32, i32* %253
br label %261
255: ; preds = %246
%256 = load i32*, i32** %7
%257 = load i32, i32* %12
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i32, i32* %256, i64 %258
%260 = load i32, i32* %259
br label %261
261: ; preds = %255, %249
%262 = phi i32 [ %254, %249 ], [ %260, %255 ]
%263 = load i32*, i32** %20
store i32 %262, i32* %263
br label %264
264: ; preds = %261, %243
br label %265
265: ; preds = %264, %221
%266 = load i32, i32* %15
%267 = icmp ne i32 %266, 0
%268 = xor i1 %267, true
%269 = zext i1 %268 to i32
store i32 %269, i32* %15
br label %75
270: ; preds = %75
%271 = load i32, i32* %18
%272 = load i32, i32* %19
%273 = add nsw i32 %271, %272
%274 = sitofp i32 %273 to double
%275 = fdiv double %274, 2.000000e+00
ret double %275
}

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