void percolate_up(int node, double *data, int *INDEX, int *INDEX2, int N) {
  int parent;
  int rxn;
  int j = INDEX[node];
  double key = data[node];
  do {
    parent = (node - 1) >> 1;
    if (key < data[parent]) {
      rxn = INDEX[parent];
      data[node] = data[parent];
      INDEX2[rxn] = node;
      INDEX[node] = rxn;
    } else
      break;
    node = parent;
  } while (parent > 0);
  data[node] = key;
  INDEX[node] = j;
  INDEX2[j] = node;
}


x86 assembly (clang, -O0):
<percolate_up>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
movsd  -0x38(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    11a8 <percolate_up+0xa8>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11ad <percolate_up+0xad>
jmp    11bd <percolate_up+0xbd>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
cmpl   $0x0,-0x28(%rbp)
jg     1137 <percolate_up+0x37>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<percolate_up>:
movslq %edi,%r9
mov    (%rdx,%r9,4),%eax
movslq %eax,%r8
movsd  (%rsi,%r9,8),%xmm0
lea    -0x1(%rdi),%eax
sar    %eax
movslq %eax,%r9
movsd  (%rsi,%r9,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1142 <percolate_up+0x42>
movslq (%rdx,%r9,4),%r10
movslq %edi,%r11
movsd  %xmm1,(%rsi,%r11,8)
mov    %edi,(%rcx,%r10,4)
mov    %r10d,(%rdx,%r11,4)
cmp    $0x2,%edi
mov    %eax,%edi
jg     1110 <percolate_up+0x10>
jmp    1147 <percolate_up+0x47>
movslq %edi,%r9
mov    %edi,%eax
movsd  %xmm0,(%rsi,%r9,8)
mov    %r8d,(%rdx,%r9,4)
mov    %eax,(%rcx,%r8,4)
ret

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

LLVM IR (-O2):
define void @percolate_up(i32 %0, double* nocapture %1, i32* nocapture %2, i32* nocapture writeonly %3, i32 %4) {
%6 = sext i32 %0 to i64
%7 = getelementptr inbounds i32, i32* %2, i64 %6
%8 = load i32, i32* %7
%9 = getelementptr inbounds double, double* %1, i64 %6
%10 = load double, double* %9
br label %11
11: ; preds = %21, %5
%12 = phi i32 [ %0, %5 ], [ %14, %21 ]
%13 = add nsw i32 %12, -1
%14 = ashr i32 %13, 1
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds double, double* %1, i64 %15
%17 = load double, double* %16
%18 = fcmp olt double %10, %17
br i1 %18, label %21, label %19
19: ; preds = %11
%20 = sext i32 %12 to i64
br label %30
21: ; preds = %11
%22 = getelementptr inbounds i32, i32* %2, i64 %15
%23 = load i32, i32* %22
%24 = sext i32 %12 to i64
%25 = getelementptr inbounds double, double* %1, i64 %24
store double %17, double* %25
%26 = sext i32 %23 to i64
%27 = getelementptr inbounds i32, i32* %3, i64 %26
store i32 %12, i32* %27
%28 = getelementptr inbounds i32, i32* %2, i64 %24
store i32 %23, i32* %28
%29 = icmp sgt i32 %12, 2
br i1 %29, label %11, label %30
30: ; preds = %21, %19
%31 = phi i64 [ %20, %19 ], [ %15, %21 ]
%32 = phi i32 [ %12, %19 ], [ %14, %21 ]
%33 = getelementptr inbounds double, double* %1, i64 %31
store double %10, double* %33
%34 = getelementptr inbounds i32, i32* %2, i64 %31
store i32 %8, i32* %34
%35 = sext i32 %8 to i64
%36 = getelementptr inbounds i32, i32* %3, i64 %35
store i32 %32, i32* %36
ret void
}