long long halton_darts(long long index, long long size) {
  int j;
  long long k, i;
  double x0, x1;
  double q0[63], q1[40];
  int d0[63], d1[40];
  double x, y;
  long long inside = 0;
  x0 = 0;
  q0[0] = 1.0 / 2;
  d0[0] = index % 2;
  k = (index - d0[0]) / 2;
  x0 += d0[0] * q0[0];
  for (j = 1; j < 63; ++j) {
    q0[j] = q0[j - 1] / 2;
    d0[j] = k % 2;
    k = (k - d0[j]) / 2;
    x0 += d0[j] * q0[j];
  }
  x1 = 0;
  q1[0] = 1.0 / 3;
  d1[0] = index % 3;
  k = (index - d1[0]) / 3;
  x1 += d1[0] * q1[0];
  for (j = 1; j < 40; ++j) {
    q1[j] = q1[j - 1] / 3;
    d1[j] = k % 3;
    k = (k - d1[j]) / 3;
    x1 += d1[j] * q1[j];
  }
  for (i = 0; i < size; ++i) {
    ++index;
    for (j = 0; j < 63; ++j) {
      ++d0[j];
      x0 += q0[j];
      if (d0[j] < 2)
        break;
      d0[j] = 0;
      x0 -= (j == 0 ? 1.0 : q0[j - 1]);
    }
    for (j = 0; j < 40; ++j) {
      ++d1[j];
      x1 += q1[j];
      if (d1[j] < 3)
        break;
      d1[j] = 0;
      x1 -= (j == 0 ? 1.0 : q1[j - 1]);
    }
    x = x0 - .5;
    y = x1 - .5;
    if (x * x + y * y <= .25)
      ++inside;
  }
  return inside;
}


x86 assembly (clang, -O0):
<halton_darts>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4c0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x528(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xed2(%rip),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %edx,%eax
mov    %eax,-0x470(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x470(%rbp),%rcx
sub    %rcx,%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x20(%rbp)
cvtsi2sdl -0x470(%rbp),%xmm0
ff
movsd  -0x230(%rbp),%xmm2
ff
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x1,-0x14(%rbp)
cmpl   $0x3f,-0x14(%rbp)
jge    123b <halton_darts+0x13b>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x230(%rbp,%rax,8),%xmm0
ff ff
movsd  0xe74(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0x230(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %edx,%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x470(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movslq -0x470(%rbp,%rcx,4),%rcx
ff
sub    %rcx,%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
cvtsi2sdl -0x470(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movsd  -0x230(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1191 <halton_darts+0x91>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xdbd(%rip),%xmm0
movsd  %xmm0,-0x370(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    $0x3,%ecx
cqto
idiv   %rcx
mov    %edx,%eax
mov    %eax,-0x510(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x510(%rbp),%rcx
sub    %rcx,%rax
mov    $0x3,%ecx
cqto
idiv   %rcx
mov    %rax,-0x20(%rbp)
cvtsi2sdl -0x510(%rbp),%xmm0
ff
movsd  -0x370(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x1,-0x14(%rbp)
cmpl   $0x28,-0x14(%rbp)
jge    1358 <halton_darts+0x258>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movsd  0xd4f(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0x370(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%rax
mov    $0x3,%ecx
cqto
idiv   %rcx
mov    %edx,%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x510(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movslq -0x510(%rbp,%rcx,4),%rcx
ff
sub    %rcx,%rax
mov    $0x3,%ecx
cqto
idiv   %rcx
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
cvtsi2sdl -0x510(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movsd  -0x370(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12ae <halton_darts+0x1ae>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    158c <halton_darts+0x48c>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x3f,-0x14(%rbp)
jge    1439 <halton_darts+0x339>
movslq -0x14(%rbp),%rax
mov    -0x470(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x470(%rbp,%rax,4)
movslq -0x14(%rbp),%rax
movsd  -0x230(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movslq -0x14(%rbp),%rax
cmpl   $0x2,-0x470(%rbp,%rax,4)
02
jge    13ce <halton_darts+0x2ce>
jmp    1439 <halton_darts+0x339>
movslq -0x14(%rbp),%rax
movl   $0x0,-0x470(%rbp,%rax,4)
cmpl   $0x0,-0x14(%rbp)
jne    13fc <halton_darts+0x2fc>
movsd  0xc21(%rip),%xmm0
movsd  %xmm0,-0x530(%rbp)
ff
jmp    1415 <halton_darts+0x315>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x230(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x530(%rbp)
ff
movsd  -0x530(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1381 <halton_darts+0x281>
movl   $0x0,-0x14(%rbp)
cmpl   $0x28,-0x14(%rbp)
jge    14f8 <halton_darts+0x3f8>
movslq -0x14(%rbp),%rax
mov    -0x510(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x510(%rbp,%rax,4)
movslq -0x14(%rbp),%rax
movsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movslq -0x14(%rbp),%rax
cmpl   $0x3,-0x510(%rbp,%rax,4)
03
jge    148d <halton_darts+0x38d>
jmp    14f8 <halton_darts+0x3f8>
movslq -0x14(%rbp),%rax
movl   $0x0,-0x510(%rbp,%rax,4)
cmpl   $0x0,-0x14(%rbp)
jne    14bb <halton_darts+0x3bb>
movsd  0xb62(%rip),%xmm0
movsd  %xmm0,-0x538(%rbp)
ff
jmp    14d4 <halton_darts+0x3d4>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x538(%rbp)
ff
movsd  -0x538(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1440 <halton_darts+0x340>
movsd  -0x30(%rbp),%xmm0
movsd  0xafb(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x518(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  0xae2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x520(%rbp)
ff
movsd  -0x518(%rbp),%xmm1
ff
movsd  -0x518(%rbp),%xmm2
ff
movsd  -0x520(%rbp),%xmm0
ff
mulsd  -0x520(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xabe(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1576 <halton_darts+0x476>
mov    -0x528(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x528(%rbp)
jmp    157b <halton_darts+0x47b>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1360 <halton_darts+0x260>
mov    -0x528(%rbp),%rax
add    $0x4c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<halton_darts>:
sub    $0x458,%rsp
mov    %rdi,%r9
movabs $0x3fe0000000000000,%rax
mov    %rax,0x260(%rsp)
mov    %rdi,%rax
shr    $0x3f,%rax
add    %r9d,%eax
and    $0xfffffffe,%eax
mov    %r9d,%ecx
sub    %eax,%ecx
mov    %ecx,0x20(%rsp)
cvtsi2sd %ecx,%xmm2
movsd  0xec2(%rip),%xmm1
mulsd  %xmm1,%xmm2
xorpd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
mov    $0x1,%eax
movapd %xmm1,%xmm2
mov    %rdi,%rdx
mov    %rdi,%rcx
nopl   0x0(%rax)
shr    $0x3f,%rcx
add    %rdx,%rcx
mov    %rcx,%rdx
sar    %rdx
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x260(%rsp,%rax,8)
shr    $0x3f,%rcx
add    %rdx,%rcx
and    $0xfffffffffffffffe,%rcx
sub    %ecx,%edx
mov    %edx,0x20(%rsp,%rax,4)
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x1,%rax
mov    %rcx,%rdx
cmp    $0x3f,%rax
jne    1160 <halton_darts+0x60>
movabs $0x3fd5555555555555,%rax
55 d5 3f
mov    %rax,0x120(%rsp)
movabs $0x5555555555555556,%r8
55 55 55
mov    %r9,%rax
imul   %r8
mov    %rdx,%rax
shr    $0x3f,%rax
add    %edx,%eax
lea    (%rax,%rax,2),%eax
mov    %r9d,%ecx
sub    %eax,%ecx
mov    %ecx,-0x80(%rsp)
xorps  %xmm3,%xmm3
cvtsi2sd %ecx,%xmm3
movsd  0xe1b(%rip),%xmm2
mulsd  %xmm2,%xmm3
xorpd  %xmm1,%xmm1
addsd  %xmm3,%xmm1
mov    $0x1,%edi
movsd  0xe0a(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
mov    %r9,%rax
imul   %r8
mov    %rdx,%rcx
shr    $0x3f,%rcx
add    %rdx,%rcx
divsd  %xmm3,%xmm2
mov    %rcx,%rax
imul   %r8
movsd  %xmm2,0x120(%rsp,%rdi,8)
mov    %rdx,%rax
shr    $0x3f,%rax
add    %rdx,%rax
lea    (%rax,%rax,2),%r9
sub    %r9d,%ecx
mov    %ecx,-0x80(%rsp,%rdi,4)
xorps  %xmm4,%xmm4
cvtsi2sd %ecx,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm4,%xmm1
add    $0x1,%rdi
cmp    $0x28,%rdi
jne    1210 <halton_darts+0x110>
test   %rsi,%rsi
jle    1387 <halton_darts+0x287>
mov    $0xffffffff,%r9d
xor    %eax,%eax
movsd  0xda6(%rip),%xmm2
movsd  0xda6(%rip),%xmm3
movsd  0xd8e(%rip),%xmm4
xor    %r8d,%r8d
jmp    12c1 <halton_darts+0x1c1>
nop
movapd %xmm0,%xmm5
addsd  %xmm2,%xmm5
movapd %xmm1,%xmm6
addsd  %xmm2,%xmm6
mulsd  %xmm6,%xmm6
mulsd  %xmm5,%xmm5
addsd  %xmm6,%xmm5
ucomisd %xmm5,%xmm3
sbb    $0xffffffffffffffff,%rax
add    $0x1,%r8
cmp    %rsi,%r8
je     137f <halton_darts+0x27f>
xor    %edi,%edi
jmp    12de <halton_darts+0x1de>
cs nopw 0x0(%rax,%rax,1)
nop
subsd  %xmm5,%xmm0
add    $0x1,%rdi
cmp    $0x3f,%rdi
je     1320 <halton_darts+0x220>
mov    0x20(%rsp,%rdi,4),%edx
lea    0x1(%rdx),%ecx
mov    %ecx,0x20(%rsp,%rdi,4)
addsd  0x260(%rsp,%rdi,8),%xmm0
test   %edx,%edx
jle    1320 <halton_darts+0x220>
movl   $0x0,0x20(%rsp,%rdi,4)
movapd %xmm4,%xmm5
test   %rdi,%rdi
je     12d0 <halton_darts+0x1d0>
lea    (%rdi,%r9,1),%ecx
movsd  0x260(%rsp,%rcx,8),%xmm5
jmp    12d0 <halton_darts+0x1d0>
cs nopw 0x0(%rax,%rax,1)
xor    %edi,%edi
jmp    1342 <halton_darts+0x242>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
subsd  %xmm5,%xmm1
add    $0x1,%rdi
cmp    $0x28,%rdi
je     1290 <halton_darts+0x190>
mov    -0x80(%rsp,%rdi,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,-0x80(%rsp,%rdi,4)
addsd  0x120(%rsp,%rdi,8),%xmm1
cmp    $0x2,%ecx
jl     1290 <halton_darts+0x190>
movl   $0x0,-0x80(%rsp,%rdi,4)
movapd %xmm4,%xmm5
test   %rdi,%rdi
je     1330 <halton_darts+0x230>
lea    (%rdi,%r9,1),%ecx
movsd  0x120(%rsp,%rcx,8),%xmm5
jmp    1330 <halton_darts+0x230>
add    $0x458,%rsp
ret
xor    %eax,%eax
add    $0x458,%rsp
ret

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

LLVM IR (-O2):
define i64 @halton_darts(i64 %0, i64 %1) {
%3 = alloca [63 x double]
%4 = alloca [40 x double]
%5 = alloca [63 x i32]
%6 = alloca [40 x i32]
%7 = bitcast [63 x double]* %3 to i8*
%8 = bitcast [40 x double]* %4 to i8*
%9 = bitcast [63 x i32]* %5 to i8*
%10 = bitcast [40 x i32]* %6 to i8*
%11 = getelementptr inbounds [63 x double], [63 x double]* %3, i64 0, i64 0
store double 5.000000e-01, double* %11
%12 = srem i64 %0, 2
%13 = trunc i64 %12 to i32
%14 = getelementptr inbounds [63 x i32], [63 x i32]* %5, i64 0, i64 0
store i32 %13, i32* %14
%15 = sitofp i32 %13 to double
%16 = tail call double @llvm.fmuladd.f64(double %15, double 5.000000e-01, double 0.000000e+00)
br label %17
17: ; preds = %2, %17
%18 = phi double [ 5.000000e-01, %2 ], [ %23, %17 ]
%19 = phi i64 [ 1, %2 ], [ %31, %17 ]
%20 = phi i64 [ %0, %2 ], [ %28, %17 ]
%21 = phi double [ %16, %2 ], [ %30, %17 ]
%22 = sdiv i64 %20, 2
%23 = fmul double %18, 5.000000e-01
%24 = getelementptr inbounds [63 x double], [63 x double]* %3, i64 0, i64 %19
store double %23, double* %24
%25 = srem i64 %22, 2
%26 = trunc i64 %25 to i32
%27 = getelementptr inbounds [63 x i32], [63 x i32]* %5, i64 0, i64 %19
store i32 %26, i32* %27
%28 = sub nsw i64 %22, %25
%29 = sitofp i32 %26 to double
%30 = tail call double @llvm.fmuladd.f64(double %29, double %23, double %21)
%31 = add nuw nsw i64 %19, 1
%32 = icmp eq i64 %31, 63
br i1 %32, label %33, label %17
33: ; preds = %17
%34 = getelementptr inbounds [40 x double], [40 x double]* %4, i64 0, i64 0
store double 0x3FD5555555555555, double* %34
%35 = srem i64 %0, 3
%36 = trunc i64 %35 to i32
%37 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 0
store i32 %36, i32* %37
%38 = sitofp i32 %36 to double
%39 = tail call double @llvm.fmuladd.f64(double %38, double 0x3FD5555555555555, double 0.000000e+00)
br label %42
40: ; preds = %42
%41 = icmp sgt i64 %1, 0
br i1 %41, label %58, label %120
42: ; preds = %33, %42
%43 = phi double [ 0x3FD5555555555555, %33 ], [ %48, %42 ]
%44 = phi i64 [ 1, %33 ], [ %56, %42 ]
%45 = phi i64 [ %0, %33 ], [ %53, %42 ]
%46 = phi double [ %39, %33 ], [ %55, %42 ]
%47 = sdiv i64 %45, 3
%48 = fdiv double %43, 3.000000e+00
%49 = getelementptr inbounds [40 x double], [40 x double]* %4, i64 0, i64 %44
store double %48, double* %49
%50 = srem i64 %47, 3
%51 = trunc i64 %50 to i32
%52 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 %44
store i32 %51, i32* %52
%53 = sub nsw i64 %47, %50
%54 = sitofp i32 %51 to double
%55 = tail call double @llvm.fmuladd.f64(double %54, double %48, double %46)
%56 = add nuw nsw i64 %44, 1
%57 = icmp eq i64 %56, 40
br i1 %57, label %40, label %42
58: ; preds = %40, %109
%59 = phi i64 [ %117, %109 ], [ 0, %40 ]
%60 = phi double [ %110, %109 ], [ %55, %40 ]
%61 = phi double [ %86, %109 ], [ %30, %40 ]
%62 = phi i64 [ %118, %109 ], [ 0, %40 ]
br label %63
63: ; preds = %58, %80
%64 = phi i64 [ 0, %58 ], [ %83, %80 ]
%65 = phi double [ %61, %58 ], [ %82, %80 ]
%66 = getelementptr inbounds [63 x i32], [63 x i32]* %5, i64 0, i64 %64
%67 = load i32, i32* %66
%68 = add nsw i32 %67, 1
store i32 %68, i32* %66
%69 = getelementptr inbounds [63 x double], [63 x double]* %3, i64 0, i64 %64
%70 = load double, double* %69
%71 = fadd double %65, %70
%72 = icmp slt i32 %67, 1
br i1 %72, label %85, label %73
73: ; preds = %63
store i32 0, i32* %66
%74 = icmp eq i64 %64, 0
br i1 %74, label %80, label %75
75: ; preds = %73
%76 = add nuw i64 %64, 4294967295
%77 = and i64 %76, 4294967295
%78 = getelementptr inbounds [63 x double], [63 x double]* %3, i64 0, i64 %77
%79 = load double, double* %78
br label %80
80: ; preds = %73, %75
%81 = phi double [ %79, %75 ], [ 1.000000e+00, %73 ]
%82 = fsub double %71, %81
%83 = add nuw nsw i64 %64, 1
%84 = icmp eq i64 %83, 63
br i1 %84, label %85, label %63
85: ; preds = %63, %80
%86 = phi double [ %71, %63 ], [ %82, %80 ]
br label %87
87: ; preds = %85, %104
%88 = phi i64 [ 0, %85 ], [ %107, %104 ]
%89 = phi double [ %60, %85 ], [ %106, %104 ]
%90 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 %88
%91 = load i32, i32* %90
%92 = add nsw i32 %91, 1
store i32 %92, i32* %90
%93 = getelementptr inbounds [40 x double], [40 x double]* %4, i64 0, i64 %88
%94 = load double, double* %93
%95 = fadd double %89, %94
%96 = icmp slt i32 %91, 2
br i1 %96, label %109, label %97
97: ; preds = %87
store i32 0, i32* %90
%98 = icmp eq i64 %88, 0
br i1 %98, label %104, label %99
99: ; preds = %97
%100 = add nuw i64 %88, 4294967295
%101 = and i64 %100, 4294967295
%102 = getelementptr inbounds [40 x double], [40 x double]* %4, i64 0, i64 %101
%103 = load double, double* %102
br label %104
104: ; preds = %97, %99
%105 = phi double [ %103, %99 ], [ 1.000000e+00, %97 ]
%106 = fsub double %95, %105
%107 = add nuw nsw i64 %88, 1
%108 = icmp eq i64 %107, 40
br i1 %108, label %109, label %87
109: ; preds = %87, %104
%110 = phi double [ %95, %87 ], [ %106, %104 ]
%111 = fadd double %86, -5.000000e-01
%112 = fadd double %110, -5.000000e-01
%113 = fmul double %112, %112
%114 = tail call double @llvm.fmuladd.f64(double %111, double %111, double %113)
%115 = fcmp ole double %114, 2.500000e-01
%116 = zext i1 %115 to i64
%117 = add nuw nsw i64 %59, %116
%118 = add nuw nsw i64 %62, 1
%119 = icmp eq i64 %118, %1
br i1 %119, label %120, label %58
120: ; preds = %109, %40
%121 = phi i64 [ 0, %40 ], [ %117, %109 ]
ret i64 %121
}