#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, long, long, long);
int roll(int);
int /*<<< orphan*/ shuffle(int *, int);
int euler_problem_84() {
  long hits[40] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  int chance[16] = {0,  10, 11,  24,  39,  5,   -1,  -1,
                    -2, -3, -10, -10, -10, -10, -10, -10};
  int comchest[16] = {0,   10,  -10, -10, -10, -10, -10, -10,
                      -10, -10, -10, -10, -10, -10, -10, -10};
  int curpos = 0, die0 = 0, die1 = 0, SIDES = 4, doubles = 0, ccpos = 0,
      chpos = 0, i = 0;
  long MAXROLLS = 10000000, currolls = 0, top0 = 0, top1 = 0, top2 = 0;
  shuffle(chance, 16);
  shuffle(comchest, 16);
  for (currolls = 0; currolls < MAXROLLS; ++currolls) {
    die0 = roll(SIDES);
    die1 = roll(SIDES);
    if (curpos + die0 + die1 > 39) {
      curpos = curpos + die0 + die1 - 39;
    } else {
      curpos = curpos + die0 + die1;
    }
    if (die0 == die1) {
      ++doubles;
    } else {
      doubles = 0;
    }
    if (doubles == 3) {
      curpos = 10;
      doubles = 0;
    }
    if (curpos == 2 || curpos == 17 || curpos == 33) {
      switch (comchest[ccpos]) {
      case -10:
        break;
      case 0:
        curpos = 0;
        break;
      case 10:
        curpos = 10;
        break;
      default:
        return 1;
      }
      ++ccpos;
      if (ccpos == 16) {
        ccpos = 0;
      }
    }
    if (curpos == 7 || curpos == 22 || curpos == 36) {
      switch (chance[chpos]) {
      case -10:
        break;
      case 0:
        curpos = 0;
        break;
      case 10:
        curpos = 10;
        break;
      case 11:
        curpos = 11;
        break;
      case 24:
        curpos = 24;
        break;
      case 39:
        curpos = 39;
        break;
      case 5:
        curpos = 5;
        break;
      case -1:
        curpos = (curpos == 7 ? 15 : (curpos == 22 ? 25 : 5));
        break;
      case -2:
        curpos = (curpos == 7 ? 12 : (curpos == 22 ? 28 : 12));
        break;
      case -3:
        curpos -= 3;
        break;
      default:
        return 2;
      }
      ++chpos;
      if (chpos == 16) {
        chpos = 0;
      }
    }
    if (curpos == 30) {
      curpos = 10;
    }
    ++hits[curpos];
  }
  for (i = 0; i < 40; ++i) {
    if (hits[i] > hits[top0]) {
      top0 = i;
    }
  }
  for (i = 0; i < 40; ++i) {
    if (hits[i] > hits[top1] && i != top0) {
      top1 = i;
    }
  }
  for (i = 0; i < 40; ++i) {
    if (hits[i] > hits[top2] && i != top0 && i != top1) {
      top2 = i;
    }
  }
  printf("%02d%02d%02d\n", top0, top1, top2);
  return 0;
}


x86 assembly (clang, -O0):
<euler_problem_84>:
push   %rbp
mov    %rsp,%rbp
sub    $0x230,%rsp
lea    -0x150(%rbp),%rdi
xor    %esi,%esi
mov    $0x140,%edx
call   1050 <memset@plt>
lea    -0x190(%rbp),%rdi
lea    0xf54(%rip),%rsi
mov    $0x40,%edx
call   1060 <memcpy@plt>
lea    -0x1d0(%rbp),%rdi
lea    0xf7c(%rip),%rsi
mov    $0x40,%edx
call   1060 <memcpy@plt>
movl   $0x0,-0x1d4(%rbp)
movl   $0x0,-0x1d8(%rbp)
movl   $0x0,-0x1dc(%rbp)
movl   $0x4,-0x1e0(%rbp)
movl   $0x0,-0x1e4(%rbp)
movl   $0x0,-0x1e8(%rbp)
movl   $0x0,-0x1ec(%rbp)
movl   $0x0,-0x1f0(%rbp)
movq   $0x989680,-0x1f8(%rbp)
movq   $0x0,-0x200(%rbp)
movq   $0x0,-0x208(%rbp)
movq   $0x0,-0x210(%rbp)
movq   $0x0,-0x218(%rbp)
lea    -0x190(%rbp),%rdi
mov    $0x10,%esi
call   1030 <shuffle@plt>
lea    -0x1d0(%rbp),%rdi
mov    $0x10,%esi
call   1030 <shuffle@plt>
movq   $0x0,-0x200(%rbp)
mov    -0x200(%rbp),%rax
cmp    -0x1f8(%rbp),%rax
jge    15de <euler_problem_84+0x48e>
mov    -0x1e0(%rbp),%edi
call   1070 <roll@plt>
mov    %eax,-0x1d8(%rbp)
mov    -0x1e0(%rbp),%edi
call   1070 <roll@plt>
mov    %eax,-0x1dc(%rbp)
mov    -0x1d4(%rbp),%eax
add    -0x1d8(%rbp),%eax
add    -0x1dc(%rbp),%eax
cmp    $0x27,%eax
jle    12c3 <euler_problem_84+0x173>
mov    -0x1d4(%rbp),%eax
add    -0x1d8(%rbp),%eax
add    -0x1dc(%rbp),%eax
sub    $0x27,%eax
mov    %eax,-0x1d4(%rbp)
jmp    12db <euler_problem_84+0x18b>
mov    -0x1d4(%rbp),%eax
add    -0x1d8(%rbp),%eax
add    -0x1dc(%rbp),%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x1d8(%rbp),%eax
cmp    -0x1dc(%rbp),%eax
jne    1301 <euler_problem_84+0x1b1>
mov    -0x1e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1e4(%rbp)
jmp    130b <euler_problem_84+0x1bb>
movl   $0x0,-0x1e4(%rbp)
cmpl   $0x3,-0x1e4(%rbp)
jne    132c <euler_problem_84+0x1dc>
movl   $0xa,-0x1d4(%rbp)
movl   $0x0,-0x1e4(%rbp)
cmpl   $0x2,-0x1d4(%rbp)
je     1353 <euler_problem_84+0x203>
cmpl   $0x11,-0x1d4(%rbp)
je     1353 <euler_problem_84+0x203>
cmpl   $0x21,-0x1d4(%rbp)
jne    13f6 <euler_problem_84+0x2a6>
movslq -0x1e8(%rbp),%rax
mov    -0x1d0(%rbp,%rax,4),%eax
mov    %eax,-0x21c(%rbp)
sub    $0xfffffff6,%eax
je     139c <euler_problem_84+0x24c>
jmp    1375 <euler_problem_84+0x225>
mov    -0x21c(%rbp),%eax
test   %eax,%eax
je     13a1 <euler_problem_84+0x251>
jmp    1388 <euler_problem_84+0x238>
mov    -0x21c(%rbp),%eax
sub    $0xa,%eax
je     13b0 <euler_problem_84+0x260>
jmp    13bf <euler_problem_84+0x26f>
jmp    13cb <euler_problem_84+0x27b>
movl   $0x0,-0x1d4(%rbp)
jmp    13cb <euler_problem_84+0x27b>
movl   $0xa,-0x1d4(%rbp)
jmp    13cb <euler_problem_84+0x27b>
movl   $0x1,-0x4(%rbp)
jmp    1768 <euler_problem_84+0x618>
mov    -0x1e8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1e8(%rbp)
cmpl   $0x10,-0x1e8(%rbp)
jne    13f1 <euler_problem_84+0x2a1>
movl   $0x0,-0x1e8(%rbp)
jmp    13f6 <euler_problem_84+0x2a6>
cmpl   $0x7,-0x1d4(%rbp)
je     141d <euler_problem_84+0x2cd>
cmpl   $0x16,-0x1d4(%rbp)
je     141d <euler_problem_84+0x2cd>
cmpl   $0x24,-0x1d4(%rbp)
jne    1595 <euler_problem_84+0x445>
movslq -0x1ec(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%eax
add    $0xa,%eax
mov    %eax,%ecx
mov    %rcx,-0x228(%rbp)
sub    $0x31,%eax
ja     155e <euler_problem_84+0x40e>
mov    -0x228(%rbp),%rax
lea    0xbb2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    156a <euler_problem_84+0x41a>
movl   $0x0,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
movl   $0xa,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
movl   $0xb,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
movl   $0x18,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
movl   $0x27,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
movl   $0x5,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
cmpl   $0x7,-0x1d4(%rbp)
jne    14d3 <euler_problem_84+0x383>
mov    $0xf,%eax
mov    %eax,-0x22c(%rbp)
jmp    14ef <euler_problem_84+0x39f>
mov    -0x1d4(%rbp),%edx
mov    $0x5,%eax
mov    $0x19,%ecx
cmp    $0x16,%edx
cmove  %ecx,%eax
mov    %eax,-0x22c(%rbp)
mov    -0x22c(%rbp),%eax
mov    %eax,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
cmpl   $0x7,-0x1d4(%rbp)
jne    151d <euler_problem_84+0x3cd>
mov    $0xc,%eax
mov    %eax,-0x230(%rbp)
jmp    1539 <euler_problem_84+0x3e9>
mov    -0x1d4(%rbp),%edx
mov    $0xc,%eax
mov    $0x1c,%ecx
cmp    $0x16,%edx
cmove  %ecx,%eax
mov    %eax,-0x230(%rbp)
mov    -0x230(%rbp),%eax
mov    %eax,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
mov    -0x1d4(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x1d4(%rbp)
jmp    156a <euler_problem_84+0x41a>
movl   $0x2,-0x4(%rbp)
jmp    1768 <euler_problem_84+0x618>
mov    -0x1ec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1ec(%rbp)
cmpl   $0x10,-0x1ec(%rbp)
jne    1590 <euler_problem_84+0x440>
movl   $0x0,-0x1ec(%rbp)
jmp    1595 <euler_problem_84+0x445>
cmpl   $0x1e,-0x1d4(%rbp)
jne    15ac <euler_problem_84+0x45c>
movl   $0xa,-0x1d4(%rbp)
movslq -0x1d4(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x150(%rbp,%rax,8)
ff
mov    -0x200(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x200(%rbp)
jmp    1252 <euler_problem_84+0x102>
movl   $0x0,-0x1f0(%rbp)
cmpl   $0x28,-0x1f0(%rbp)
jge    1640 <euler_problem_84+0x4f0>
movslq -0x1f0(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rax
ff
mov    -0x208(%rbp),%rcx
cmp    -0x150(%rbp,%rcx,8),%rax
ff
jle    1627 <euler_problem_84+0x4d7>
movslq -0x1f0(%rbp),%rax
mov    %rax,-0x208(%rbp)
jmp    162c <euler_problem_84+0x4dc>
mov    -0x1f0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f0(%rbp)
jmp    15e8 <euler_problem_84+0x498>
movl   $0x0,-0x1f0(%rbp)
cmpl   $0x28,-0x1f0(%rbp)
jge    16b6 <euler_problem_84+0x566>
movslq -0x1f0(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rax
ff
mov    -0x210(%rbp),%rcx
cmp    -0x150(%rbp,%rcx,8),%rax
ff
jle    169d <euler_problem_84+0x54d>
movslq -0x1f0(%rbp),%rax
cmp    -0x208(%rbp),%rax
je     169d <euler_problem_84+0x54d>
movslq -0x1f0(%rbp),%rax
mov    %rax,-0x210(%rbp)
jmp    16a2 <euler_problem_84+0x552>
mov    -0x1f0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f0(%rbp)
jmp    164a <euler_problem_84+0x4fa>
movl   $0x0,-0x1f0(%rbp)
cmpl   $0x28,-0x1f0(%rbp)
jge    1740 <euler_problem_84+0x5f0>
movslq -0x1f0(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rax
ff
mov    -0x218(%rbp),%rcx
cmp    -0x150(%rbp,%rcx,8),%rax
ff
jle    1727 <euler_problem_84+0x5d7>
movslq -0x1f0(%rbp),%rax
cmp    -0x208(%rbp),%rax
je     1727 <euler_problem_84+0x5d7>
movslq -0x1f0(%rbp),%rax
cmp    -0x210(%rbp),%rax
je     1727 <euler_problem_84+0x5d7>
movslq -0x1f0(%rbp),%rax
mov    %rax,-0x218(%rbp)
jmp    172c <euler_problem_84+0x5dc>
mov    -0x1f0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f0(%rbp)
jmp    16c0 <euler_problem_84+0x570>
mov    -0x208(%rbp),%rsi
mov    -0x210(%rbp),%rdx
mov    -0x218(%rbp),%rcx
lea    0x9f4(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x230,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<euler_problem_84>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
lea    0x80(%rsp),%rdi
mov    $0x140,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movaps 0xf94(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xf78(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xf5c(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xf40(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xfa4(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xf88(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xf6c(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xf50(%rip),%xmm0
movaps %xmm0,(%rsp)
lea    0x40(%rsp),%rdi
mov    $0x10,%esi
call   1030 <shuffle@plt>
mov    %rsp,%rdi
mov    $0x10,%esi
call   1030 <shuffle@plt>
mov    $0x989680,%ebp
xor    %r12d,%r12d
xor    %r15d,%r15d
xor    %r13d,%r13d
xor    %r14d,%r14d
jmp    1216 <euler_problem_84+0xd6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %r14d,%rax
addq   $0x1,0x80(%rsp,%rax,8)
add    $0xffffffffffffffff,%rbp
je     1342 <euler_problem_84+0x202>
mov    $0x4,%edi
call   1060 <roll@plt>
mov    %eax,%ebx
mov    $0x4,%edi
call   1060 <roll@plt>
add    %ebx,%r14d
lea    (%r14,%rax,1),%edx
cmp    $0x28,%edx
lea    -0x27(%rax,%r14,1),%ecx
cmovl  %edx,%ecx
add    $0x1,%r13d
cmp    %eax,%ebx
mov    $0x0,%edi
cmovne %edi,%r13d
cmp    $0x3,%r13d
mov    $0xa,%eax
cmove  %eax,%ecx
cmove  %edi,%r13d
cmp    $0x21,%ecx
ja     129e <euler_problem_84+0x15e>
movabs $0x200020004,%rax
bt     %rcx,%rax
jae    129e <euler_problem_84+0x15e>
movslq %r15d,%rax
mov    (%rsp,%rax,4),%eax
cmp    $0xfffffff6,%eax
je     1292 <euler_problem_84+0x152>
cmp    $0xa,%eax
je     1290 <euler_problem_84+0x150>
mov    %eax,%ecx
test   %eax,%eax
je     1292 <euler_problem_84+0x152>
jmp    1498 <euler_problem_84+0x358>
nopl   (%rax)
mov    %eax,%ecx
add    $0x1,%r15d
cmp    $0x10,%r15d
cmove  %edi,%r15d
cmp    $0x24,%ecx
ja     12eb <euler_problem_84+0x1ab>
mov    %ecx,%eax
movabs $0x1000400080,%rdx
bt     %rax,%rdx
jae    12eb <euler_problem_84+0x1ab>
movslq %r12d,%rax
mov    0x40(%rsp,%rax,4),%edx
mov    $0x2,%eax
lea    0xa(%rdx),%esi
cmp    $0x31,%esi
ja     149d <euler_problem_84+0x35d>
lea    0xd2c(%rip),%rbx
movslq (%rbx,%rsi,4),%rsi
add    %rbx,%rsi
jmp    *%rsi
mov    %edx,%ecx
add    $0x1,%r12d
cmp    $0x10,%r12d
cmove  %edi,%r12d
mov    $0xa,%r14d
cmp    $0x1e,%ecx
je     1200 <euler_problem_84+0xc0>
mov    %ecx,%r14d
jmp    1200 <euler_problem_84+0xc0>
add    $0xfffffffd,%ecx
jmp    12df <euler_problem_84+0x19f>
xor    %eax,%eax
cmp    $0x16,%ecx
sete   %dl
cmp    $0x7,%ecx
mov    $0xc,%ecx
je     12df <euler_problem_84+0x19f>
mov    %dl,%al
shl    $0x4,%eax
or     $0xc,%eax
mov    %eax,%ecx
jmp    12df <euler_problem_84+0x19f>
mov    $0x19,%eax
cmp    $0x16,%ecx
je     1334 <euler_problem_84+0x1f4>
mov    $0x5,%eax
cmp    $0x7,%ecx
mov    $0xf,%ecx
je     12df <euler_problem_84+0x19f>
mov    %eax,%ecx
jmp    12df <euler_problem_84+0x19f>
xor    %eax,%eax
xor    %esi,%esi
jmp    135d <euler_problem_84+0x21d>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rsi
add    $0x5,%rax
cmp    $0x28,%rax
je     13cf <euler_problem_84+0x28f>
mov    0x80(%rsp,%rax,8),%rdx
mov    %rax,%rcx
cmp    0x80(%rsp,%rsi,8),%rdx
jg     1375 <euler_problem_84+0x235>
mov    %rsi,%rcx
mov    0x88(%rsp,%rax,8),%rdx
cmp    0x80(%rsp,%rcx,8),%rdx
jle    138b <euler_problem_84+0x24b>
lea    0x1(%rax),%rcx
mov    0x90(%rsp,%rax,8),%rdx
cmp    0x80(%rsp,%rcx,8),%rdx
jle    13a1 <euler_problem_84+0x261>
lea    0x2(%rax),%rcx
mov    0x98(%rsp,%rax,8),%rdx
cmp    0x80(%rsp,%rcx,8),%rdx
jle    13b7 <euler_problem_84+0x277>
lea    0x3(%rax),%rcx
mov    0xa0(%rsp,%rax,8),%rdx
cmp    0x80(%rsp,%rcx,8),%rdx
jle    1350 <euler_problem_84+0x210>
lea    0x4(%rax),%rsi
jmp    1353 <euler_problem_84+0x213>
xor    %eax,%eax
xor    %edx,%edx
jmp    13ea <euler_problem_84+0x2aa>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rax
cmp    $0x28,%rax
je     142b <euler_problem_84+0x2eb>
cmp    %rax,%rsi
mov    %rax,%rcx
cmove  %rdx,%rcx
mov    0x80(%rsp,%rax,8),%rdi
cmp    0x80(%rsp,%rdx,8),%rdi
jle    1409 <euler_problem_84+0x2c9>
mov    %rcx,%rdx
mov    0x88(%rsp,%rax,8),%rdi
lea    0x1(%rax),%rcx
cmp    %rcx,%rsi
cmove  %rdx,%rcx
cmp    0x80(%rsp,%rdx,8),%rdi
jle    13e0 <euler_problem_84+0x2a0>
mov    %rcx,%rdx
jmp    13e0 <euler_problem_84+0x2a0>
xor    %eax,%eax
xor    %ecx,%ecx
nop
cmp    %rax,%rdx
mov    %rax,%rdi
cmove  %rcx,%rdi
cmp    %rax,%rsi
cmove  %rcx,%rdi
mov    0x80(%rsp,%rax,8),%rbp
cmp    0x80(%rsp,%rcx,8),%rbp
mov    0x88(%rsp,%rax,8),%rbp
cmovle %rcx,%rdi
lea    0x1(%rax),%rbx
cmp    %rbx,%rdx
mov    %rbx,%rcx
cmove  %rdi,%rcx
cmp    %rbx,%rsi
cmove  %rdi,%rcx
cmp    0x80(%rsp,%rdi,8),%rbp
cmovle %rdi,%rcx
add    $0x2,%rax
cmp    $0x28,%rax
jne    1430 <euler_problem_84+0x2f0>
lea    0xcc1(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
jmp    149d <euler_problem_84+0x35d>
mov    $0x1,%eax
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@__const.euler_problem_84.chance = [16 x i32] [i32 0, i32 10, i32 11, i32 24, i32 39, i32 5, i32 -1, i32 -1, i32 -2, i32 -3, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10]
@__const.euler_problem_84.comchest = [16 x i32] [i32 0, i32 10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10, i32 -10]
@.str = [14 x i8] c"%02d%02d%02d\0A\00"
define i32 @euler_problem_84() {
%1 = alloca [40 x i64]
%2 = alloca [16 x i32]
%3 = alloca [16 x i32]
%4 = bitcast [40 x i64]* %1 to i8*
%5 = bitcast [16 x i32]* %2 to i8*
%6 = bitcast [16 x i32]* %3 to i8*
%7 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 0
%8 = call i32 @shuffle(i32* %7, i32 16)
%9 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 0
%10 = call i32 @shuffle(i32* %9, i32 16)
br label %11
11: ; preds = %0, %69
%12 = phi i64 [ 0, %0 ], [ %78, %69 ]
%13 = phi i32 [ 0, %0 ], [ %71, %69 ]
%14 = phi i32 [ 0, %0 ], [ %43, %69 ]
%15 = phi i32 [ 0, %0 ], [ %29, %69 ]
%16 = phi i32 [ 0, %0 ], [ %73, %69 ]
%17 = call i32 @roll(i32 4)
%18 = call i32 @roll(i32 4)
%19 = add nsw i32 %17, %16
%20 = add nsw i32 %19, %18
%21 = icmp sgt i32 %20, 39
%22 = add nsw i32 %20, -39
%23 = select i1 %21, i32 %22, i32 %20
%24 = icmp eq i32 %17, %18
%25 = add nsw i32 %15, 1
%26 = select i1 %24, i32 %25, i32 0
%27 = icmp eq i32 %26, 3
%28 = select i1 %27, i32 10, i32 %23
%29 = select i1 %27, i32 0, i32 %26
switch i32 %28, label %41 [
i32 33, label %30
i32 17, label %30
i32 2, label %30
]
30: ; preds = %11, %11, %11
%31 = sext i32 %14 to i64
%32 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 %31
%33 = load i32, i32* %32
switch i32 %33, label %169 [
i32 -10, label %36
i32 0, label %34
i32 10, label %35
]
34: ; preds = %30
br label %36
35: ; preds = %30
br label %36
36: ; preds = %35, %34, %30
%37 = phi i32 [ %33, %35 ], [ %33, %34 ], [ %28, %30 ]
%38 = add nsw i32 %14, 1
%39 = icmp eq i32 %38, 16
%40 = select i1 %39, i32 0, i32 %38
br label %41
41: ; preds = %11, %36
%42 = phi i32 [ %37, %36 ], [ %28, %11 ]
%43 = phi i32 [ %40, %36 ], [ %14, %11 ]
%44 = icmp eq i32 %42, 7
%45 = icmp eq i32 %42, 22
switch i32 %42, label %69 [
i32 36, label %46
i32 22, label %46
i32 7, label %46
]
46: ; preds = %41, %41, %41
%47 = sext i32 %13 to i64
%48 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %47
%49 = load i32, i32* %48
switch i32 %49, label %169 [
i32 -10, label %64
i32 0, label %50
i32 10, label %51
i32 11, label %52
i32 24, label %53
i32 39, label %54
i32 5, label %55
i32 -1, label %56
i32 -2, label %59
i32 -3, label %62
]
50: ; preds = %46
br label %64
51: ; preds = %46
br label %64
52: ; preds = %46
br label %64
53: ; preds = %46
br label %64
54: ; preds = %46
br label %64
55: ; preds = %46
br label %64
56: ; preds = %46
%57 = select i1 %45, i32 25, i32 5
%58 = select i1 %44, i32 15, i32 %57
br label %64
59: ; preds = %46
%60 = select i1 %45, i32 28, i32 12
%61 = select i1 %44, i32 12, i32 %60
br label %64
62: ; preds = %46
%63 = add nsw i32 %42, -3
br label %64
64: ; preds = %62, %59, %56, %55, %54, %53, %52, %51, %50, %46
%65 = phi i32 [ %63, %62 ], [ %61, %59 ], [ %58, %56 ], [ %49, %55 ], [ %49, %54 ], [ %49, %53 ], [ %49, %52 ], [ %49, %51 ], [ %49, %50 ], [ %42, %46 ]
%66 = add nsw i32 %13, 1
%67 = icmp eq i32 %66, 16
%68 = select i1 %67, i32 0, i32 %66
br label %69
69: ; preds = %41, %64
%70 = phi i32 [ %65, %64 ], [ %42, %41 ]
%71 = phi i32 [ %68, %64 ], [ %13, %41 ]
%72 = icmp eq i32 %70, 30
%73 = select i1 %72, i32 10, i32 %70
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %74
%76 = load i64, i64* %75
%77 = add nsw i64 %76, 1
store i64 %77, i64* %75
%78 = add nuw nsw i64 %12, 1
%79 = icmp eq i64 %78, 10000000
br i1 %79, label %80, label %11
80: ; preds = %69, %80
%81 = phi i64 [ %117, %80 ], [ 0, %69 ]
%82 = phi i64 [ %116, %80 ], [ 0, %69 ]
%83 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %81
%84 = load i64, i64* %83
%85 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %82
%86 = load i64, i64* %85
%87 = icmp sgt i64 %84, %86
%88 = select i1 %87, i64 %81, i64 %82
%89 = add nuw nsw i64 %81, 1
%90 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %89
%91 = load i64, i64* %90
%92 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %88
%93 = load i64, i64* %92
%94 = icmp sgt i64 %91, %93
%95 = select i1 %94, i64 %89, i64 %88
%96 = add nuw nsw i64 %81, 2
%97 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %96
%98 = load i64, i64* %97
%99 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %95
%100 = load i64, i64* %99
%101 = icmp sgt i64 %98, %100
%102 = select i1 %101, i64 %96, i64 %95
%103 = add nuw nsw i64 %81, 3
%104 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %103
%105 = load i64, i64* %104
%106 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %102
%107 = load i64, i64* %106
%108 = icmp sgt i64 %105, %107
%109 = select i1 %108, i64 %103, i64 %102
%110 = add nuw nsw i64 %81, 4
%111 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %110
%112 = load i64, i64* %111
%113 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %109
%114 = load i64, i64* %113
%115 = icmp sgt i64 %112, %114
%116 = select i1 %115, i64 %110, i64 %109
%117 = add nuw nsw i64 %81, 5
%118 = icmp eq i64 %117, 40
br i1 %118, label %119, label %80
119: ; preds = %80, %119
%120 = phi i64 [ %139, %119 ], [ 0, %80 ]
%121 = phi i64 [ %138, %119 ], [ 0, %80 ]
%122 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %120
%123 = load i64, i64* %122
%124 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %121
%125 = load i64, i64* %124
%126 = icmp sle i64 %123, %125
%127 = icmp eq i64 %116, %120
%128 = select i1 %126, i1 true, i1 %127
%129 = select i1 %128, i64 %121, i64 %120
%130 = or i64 %120, 1
%131 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %130
%132 = load i64, i64* %131
%133 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %129
%134 = load i64, i64* %133
%135 = icmp sle i64 %132, %134
%136 = icmp eq i64 %116, %130
%137 = select i1 %135, i1 true, i1 %136
%138 = select i1 %137, i64 %129, i64 %130
%139 = add nuw nsw i64 %120, 2
%140 = icmp eq i64 %139, 40
br i1 %140, label %141, label %119
141: ; preds = %119, %141
%142 = phi i64 [ %165, %141 ], [ 0, %119 ]
%143 = phi i64 [ %164, %141 ], [ 0, %119 ]
%144 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %142
%145 = load i64, i64* %144
%146 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %143
%147 = load i64, i64* %146
%148 = icmp sle i64 %145, %147
%149 = icmp eq i64 %116, %142
%150 = select i1 %148, i1 true, i1 %149
%151 = icmp eq i64 %138, %142
%152 = select i1 %150, i1 true, i1 %151
%153 = select i1 %152, i64 %143, i64 %142
%154 = or i64 %142, 1
%155 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %154
%156 = load i64, i64* %155
%157 = getelementptr inbounds [40 x i64], [40 x i64]* %1, i64 0, i64 %153
%158 = load i64, i64* %157
%159 = icmp sle i64 %156, %158
%160 = icmp eq i64 %116, %154
%161 = select i1 %159, i1 true, i1 %160
%162 = icmp eq i64 %138, %154
%163 = select i1 %161, i1 true, i1 %162
%164 = select i1 %163, i64 %153, i64 %154
%165 = add nuw nsw i64 %142, 2
%166 = icmp eq i64 %165, 40
br i1 %166, label %167, label %141
167: ; preds = %141
%168 = call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i64 %116, i64 %138, i64 %164)
br label %169
169: ; preds = %46, %30, %167
%170 = phi i32 [ 0, %167 ], [ 2, %46 ], [ 1, %30 ]
ret i32 %170
}