#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 *, ...);
void dijsktra(int cost[100][100], int N, int source) {
  int dist[100], predecessor[100], visited[100];
  int i, count;
  for (i = 0; i < N; i++) {
    dist[i] = 9999;
    predecessor[i] = -1;
    visited[i] = 0;
  }
  dist[source] = 0;
  predecessor[source] = source;
  count = 0;
  while (count <= N) {
    int min = 9999, u = 0;
    for (i = 0; i < N; i++) {
      if (dist[i] < min && !visited[i]) {
        min = dist[i];
        u = i;
      }
    }
    visited[u] = 1;
    for (i = 0; i < N; i++) {
      if (dist[u] + cost[u][i] < dist[i] && !visited[i]) {
        dist[i] = dist[u] + cost[u][i];
        predecessor[i] = u;
      }
    }
    count++;
  }
  for (i = 0; i < N; i++) {
    if (i != source) {
      printf("Path %d to %d : cost : %d : Path : ", source, i, dist[i]);
      int path[100] = {0}, top = -1, j = i;
      path[++top] = i;
      while (predecessor[j] != source) {
        j = predecessor[j];
        path[++top] = j;
      }
      path[++top] = source;
      while (top != -1) {
        printf("%d ", path[top--]);
        if (top != -1)
          printf("-> ");
      }
      printf("\n");
    }
  }
}


x86 assembly (clang, -O0):
<dijsktra>:
push   %rbp
mov    %rsp,%rbp
sub    $0x670,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1198 <dijsktra+0x78>
movslq -0x4c4(%rbp),%rax
movl   $0x270f,-0x1a0(%rbp,%rax,4)
movslq -0x4c4(%rbp),%rax
movl   $0xffffffff,-0x330(%rbp,%rax,4)
ff ff ff ff
movslq -0x4c4(%rbp),%rax
movl   $0x0,-0x4c0(%rbp,%rax,4)
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    113f <dijsktra+0x1f>
movslq -0x10(%rbp),%rax
movl   $0x0,-0x1a0(%rbp,%rax,4)
mov    -0x10(%rbp),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x330(%rbp,%rax,4)
movl   $0x0,-0x4c8(%rbp)
mov    -0x4c8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1360 <dijsktra+0x240>
movl   $0x270f,-0x4cc(%rbp)
movl   $0x0,-0x4d0(%rbp)
movl   $0x0,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1263 <dijsktra+0x143>
movslq -0x4c4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
cmp    -0x4cc(%rbp),%eax
jge    124a <dijsktra+0x12a>
movslq -0x4c4(%rbp),%rax
cmpl   $0x0,-0x4c0(%rbp,%rax,4)
jne    124a <dijsktra+0x12a>
movslq -0x4c4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
mov    %eax,-0x4cc(%rbp)
mov    -0x4c4(%rbp),%eax
mov    %eax,-0x4d0(%rbp)
jmp    124f <dijsktra+0x12f>
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    11ec <dijsktra+0xcc>
movslq -0x4d0(%rbp),%rax
movl   $0x1,-0x4c0(%rbp,%rax,4)
movl   $0x0,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    134c <dijsktra+0x22c>
movslq -0x4d0(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x4d0(%rbp),%rdx
imul   $0x190,%rdx,%rdx
add    %rdx,%rcx
movslq -0x4c4(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
movslq -0x4c4(%rbp),%rcx
cmp    -0x1a0(%rbp,%rcx,4),%eax
jge    1333 <dijsktra+0x213>
movslq -0x4c4(%rbp),%rax
cmpl   $0x0,-0x4c0(%rbp,%rax,4)
jne    1333 <dijsktra+0x213>
movslq -0x4d0(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%rax
movslq -0x4d0(%rbp),%rdx
imul   $0x190,%rdx,%rdx
add    %rdx,%rax
movslq -0x4c4(%rbp),%rdx
add    (%rax,%rdx,4),%ecx
movslq -0x4c4(%rbp),%rax
mov    %ecx,-0x1a0(%rbp,%rax,4)
mov    -0x4d0(%rbp),%ecx
movslq -0x4c4(%rbp),%rax
mov    %ecx,-0x330(%rbp,%rax,4)
jmp    1338 <dijsktra+0x218>
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    127f <dijsktra+0x15f>
mov    -0x4c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c8(%rbp)
jmp    11bf <dijsktra+0x9f>
movl   $0x0,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14d9 <dijsktra+0x3b9>
mov    -0x4c4(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     14c0 <dijsktra+0x3a0>
mov    -0x10(%rbp),%esi
mov    -0x4c4(%rbp),%edx
movslq -0x4c4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%ecx
lea    0xc5a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x660(%rbp),%rdi
xor    %esi,%esi
mov    $0x190,%edx
call   1040 <memset@plt>
movl   $0xffffffff,-0x664(%rbp)
ff ff ff
mov    -0x4c4(%rbp),%eax
mov    %eax,-0x668(%rbp)
mov    -0x4c4(%rbp),%ecx
mov    -0x664(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x664(%rbp)
cltq
mov    %ecx,-0x660(%rbp,%rax,4)
movslq -0x668(%rbp),%rax
mov    -0x330(%rbp,%rax,4),%eax
cmp    -0x10(%rbp),%eax
je     1442 <dijsktra+0x322>
movslq -0x668(%rbp),%rax
mov    -0x330(%rbp,%rax,4),%eax
mov    %eax,-0x668(%rbp)
mov    -0x668(%rbp),%ecx
mov    -0x664(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x664(%rbp)
cltq
mov    %ecx,-0x660(%rbp,%rax,4)
jmp    13f4 <dijsktra+0x2d4>
mov    -0x10(%rbp),%ecx
mov    -0x664(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x664(%rbp)
cltq
mov    %ecx,-0x660(%rbp,%rax,4)
cmpl   $0xffffffff,-0x664(%rbp)
je     14b2 <dijsktra+0x392>
mov    -0x664(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x664(%rbp)
cltq
mov    -0x660(%rbp,%rax,4),%esi
lea    0xb99(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0xffffffff,-0x664(%rbp)
je     14ad <dijsktra+0x38d>
lea    0xb82(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    145d <dijsktra+0x33d>
lea    0xb73(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    14c5 <dijsktra+0x3a5>
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    136a <dijsktra+0x24a>
add    $0x670,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dijsktra>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x658,%rsp
mov    %edx,%r12d
mov    %esi,%r15d
mov    %esi,%r14d
test   %esi,%esi
jle    1291 <dijsktra+0x161>
mov    %rdi,%rbp
lea    0x0(,%r14,4),%r13
lea    0x4c0(%rsp),%rdi
mov    $0xff,%esi
mov    %r13,%rdx
call   1050 <memset@plt>
lea    0x330(%rsp),%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    %r13,%rdx
call   1050 <memset@plt>
cmp    $0x8,%r15d
jae    1194 <dijsktra+0x64>
mov    %rbp,%rdi
jmp    1280 <dijsktra+0x150>
mov    %r14d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%eax
and    $0x7,%eax
cmp    $0x38,%rdx
jae    11be <dijsktra+0x8e>
xor    %edx,%edx
mov    %rbp,%rdi
jmp    1245 <dijsktra+0x115>
and    $0xfffffffffffffff8,%rcx
xor    %edx,%edx
movaps 0xe35(%rip),%xmm0
mov    %rbp,%rdi
xchg   %ax,%ax
movaps %xmm0,0x10(%rsp,%rdx,4)
movaps %xmm0,0x20(%rsp,%rdx,4)
movaps %xmm0,0x30(%rsp,%rdx,4)
movaps %xmm0,0x40(%rsp,%rdx,4)
movaps %xmm0,0x50(%rsp,%rdx,4)
movaps %xmm0,0x60(%rsp,%rdx,4)
movaps %xmm0,0x70(%rsp,%rdx,4)
movaps %xmm0,0x80(%rsp,%rdx,4)
movaps %xmm0,0x90(%rsp,%rdx,4)
movaps %xmm0,0xa0(%rsp,%rdx,4)
movaps %xmm0,0xb0(%rsp,%rdx,4)
movaps %xmm0,0xc0(%rsp,%rdx,4)
movaps %xmm0,0xd0(%rsp,%rdx,4)
movaps %xmm0,0xe0(%rsp,%rdx,4)
movaps %xmm0,0xf0(%rsp,%rdx,4)
movaps %xmm0,0x100(%rsp,%rdx,4)
add    $0x40,%rdx
add    $0xfffffffffffffff8,%rcx
jne    11d0 <dijsktra+0xa0>
test   %rax,%rax
je     1272 <dijsktra+0x142>
lea    (%rsp,%rdx,4),%rcx
add    $0x20,%rcx
shl    $0x5,%rax
xor    %edx,%edx
movaps 0xda1(%rip),%xmm0
nop
movaps %xmm0,-0x10(%rcx,%rdx,1)
movaps %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rax
jne    1260 <dijsktra+0x130>
cmp    %r14,%rbx
je     1291 <dijsktra+0x161>
nopw   0x0(%rax,%rax,1)
movl   $0x270f,0x10(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1280 <dijsktra+0x150>
movslq %r12d,%rax
movl   $0x0,0x10(%rsp,%rax,4)
mov    %eax,0x4c0(%rsp,%rax,4)
test   %r15d,%r15d
js     139a <dijsktra+0x26a>
mov    %r14d,%eax
and    $0xfffffffe,%eax
xor    %r8d,%r8d
jmp    12db <dijsktra+0x1ab>
nopw   0x0(%rax,%rax,1)
movl   $0x1,0x330(%rsp)
lea    0x1(%r8),%edx
cmp    %r15d,%r8d
mov    %edx,%r8d
je     139a <dijsktra+0x26a>
test   %r15d,%r15d
je     12c0 <dijsktra+0x190>
mov    $0x270f,%ecx
xor    %esi,%esi
xor    %edx,%edx
cmp    $0x1,%r15d
jne    1369 <dijsktra+0x239>
test   $0x1,%r14b
je     1306 <dijsktra+0x1d6>
cmp    %ecx,0x10(%rsp,%rsi,4)
jge    1306 <dijsktra+0x1d6>
cmpl   $0x0,0x330(%rsp,%rsi,4)
cmove  %esi,%edx
movslq %edx,%rsi
movl   $0x1,0x330(%rsp,%rsi,4)
test   %r15d,%r15d
je     12cb <dijsktra+0x19b>
imul   $0x190,%rsi,%rcx
add    %rdi,%rcx
xor    %ebx,%ebx
jmp    1339 <dijsktra+0x209>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%r14
je     12cb <dijsktra+0x19b>
mov    (%rcx,%rbx,4),%ebp
add    0x10(%rsp,%rsi,4),%ebp
cmp    0x10(%rsp,%rbx,4),%ebp
jge    1330 <dijsktra+0x200>
cmpl   $0x0,0x330(%rsp,%rbx,4)
jne    1330 <dijsktra+0x200>
mov    %ebp,0x10(%rsp,%rbx,4)
mov    %edx,0x4c0(%rsp,%rbx,4)
jmp    1330 <dijsktra+0x200>
nopl   (%rax)
add    $0x2,%rsi
cmp    %rsi,%rax
je     12ef <dijsktra+0x1bf>
mov    0x10(%rsp,%rsi,4),%ebp
cmp    %ecx,%ebp
jge    137f <dijsktra+0x24f>
cmpl   $0x0,0x330(%rsp,%rsi,4)
cmove  %ebp,%ecx
cmove  %esi,%edx
mov    0x14(%rsp,%rsi,4),%ebp
cmp    %ecx,%ebp
jge    1360 <dijsktra+0x230>
lea    0x1(%rsi),%ebx
cmpl   $0x0,0x334(%rsp,%rsi,4)
cmove  %ebp,%ecx
cmove  %ebx,%edx
jmp    1360 <dijsktra+0x230>
test   %r15d,%r15d
jle    14c7 <dijsktra+0x397>
mov    %r12d,%eax
lea    0xc87(%rip),%rbp
lea    0xc84(%rip),%r13
xor    %ebx,%ebx
mov    %rax,0x8(%rsp)
jmp    13dc <dijsktra+0x2ac>
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x8(%rsp),%rax
add    $0x1,%rbx
cmp    %r14,%rbx
je     14c7 <dijsktra+0x397>
cmp    %rax,%rbx
je     13cf <dijsktra+0x29f>
mov    0x10(%rsp,%rbx,4),%ecx
lea    0xc24(%rip),%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x190,%edx
lea    0x1a0(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    %ebx,0x1a0(%rsp)
mov    0x4c0(%rsp,%rbx,4),%ecx
cmp    %r12d,%ecx
jne    1430 <dijsktra+0x300>
mov    %r12d,0x1a4(%rsp)
xor    %eax,%eax
jmp    1471 <dijsktra+0x341>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,0x1a0(%rsp,%rax,4)
movslq %ecx,%rcx
mov    0x4c0(%rsp,%rcx,4),%ecx
add    $0x1,%rax
cmp    %r12d,%ecx
jne    1440 <dijsktra+0x310>
mov    %eax,%ecx
mov    %r12d,0x1a0(%rsp,%rcx,4)
cmp    $0xffffffff,%eax
je     13c0 <dijsktra+0x290>
add    $0xffffffffffffffff,%rax
movslq %eax,%r15
lea    0x1(%r15),%rax
mov    0x1a0(%rsp,%rax,4),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rax
inc    %rax
je     13c0 <dijsktra+0x290>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1a0(%rsp,%r15,4),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0xffffffffffffffff,%r15
jb     14a0 <dijsktra+0x370>
jmp    13c0 <dijsktra+0x290>
add    $0x658,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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