#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*/ getchar();
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ scanf(char *, int *, int *, ...);
int main(int argc, const char *argv[]) {
  int e[10][10], dis[10], book[10], i, j, n, m, t1, t2, t3, u, v, min;
  u = 0;
  int inf = 999999999;
  scanf("%d %d", &n, &m);
  for (i = 1; i <= n; i++) {
    for (j = 1; j <= n; j++) {
      if (i == j) {
        e[i][j] = 0;
      } else {
        e[i][j] = inf;
      }
    }
  }
  for (i = 1; i <= m; i++) {
    scanf("%d %d %d", &t1, &t2, &t3);
    e[t1][t2] = t3;
  }
  for (i = 1; i <= n; i++) {
    dis[i] = e[1][i];
  }
  for (i = 1; i <= n; i++) {
    book[i] = 0;
  }
  book[1] = 1;
  for (i = 1; i < n; i++) {
    min = inf;
    for (j = 1; j <= n; j++) {
      if (book[j] == 0 && dis[j] < min) {
        min = dis[j];
        u = j;
      }
    }
    book[u] = 1;
    for (v = 1; v <= n; v++) {
      if (e[u][v] < inf) {
        if (dis[v] > dis[u] + e[u][v]) {
          dis[v] = dis[u] + e[u][v];
        }
      }
    }
  }
  for (i = 1; i <= n; i++) {
    printf("%d ", dis[i]);
  }
  getchar();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x230,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x220(%rbp)
movl   $0x3b9ac9ff,-0x22c(%rbp)
c9 9a 3b
lea    0xe9f(%rip),%rdi
lea    -0x20c(%rbp),%rsi
lea    -0x210(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x1,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jg     1242 <main+0x112>
movl   $0x1,-0x208(%rbp)
mov    -0x208(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jg     1229 <main+0xf9>
mov    -0x204(%rbp),%eax
cmp    -0x208(%rbp),%eax
jne    11eb <main+0xbb>
movslq -0x204(%rbp),%rcx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x208(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1210 <main+0xe0>
mov    -0x22c(%rbp),%edx
movslq -0x204(%rbp),%rcx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x208(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1215 <main+0xe5>
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
jmp    119f <main+0x6f>
jmp    122e <main+0xfe>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1183 <main+0x53>
movl   $0x1,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x210(%rbp),%eax
jg     12ba <main+0x18a>
lea    0xd9b(%rip),%rdi
lea    -0x214(%rbp),%rsi
lea    -0x218(%rbp),%rdx
lea    -0x21c(%rbp),%rcx
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x21c(%rbp),%edx
movslq -0x214(%rbp),%rcx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x218(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    124c <main+0x11c>
movl   $0x1,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jg     1306 <main+0x1d6>
movslq -0x204(%rbp),%rax
mov    -0x178(%rbp,%rax,4),%ecx
movslq -0x204(%rbp),%rax
mov    %ecx,-0x1d0(%rbp,%rax,4)
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    12c4 <main+0x194>
movl   $0x1,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jg     1348 <main+0x218>
movslq -0x204(%rbp),%rax
movl   $0x0,-0x200(%rbp,%rax,4)
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1310 <main+0x1e0>
movl   $0x1,-0x1fc(%rbp)
movl   $0x1,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jge    150c <main+0x3dc>
mov    -0x22c(%rbp),%eax
mov    %eax,-0x228(%rbp)
movl   $0x1,-0x208(%rbp)
mov    -0x208(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jg     13fe <main+0x2ce>
movslq -0x208(%rbp),%rax
cmpl   $0x0,-0x200(%rbp,%rax,4)
jne    13e5 <main+0x2b5>
movslq -0x208(%rbp),%rax
mov    -0x1d0(%rbp,%rax,4),%eax
cmp    -0x228(%rbp),%eax
jge    13e5 <main+0x2b5>
movslq -0x208(%rbp),%rax
mov    -0x1d0(%rbp,%rax,4),%eax
mov    %eax,-0x228(%rbp)
mov    -0x208(%rbp),%eax
mov    %eax,-0x220(%rbp)
jmp    13ea <main+0x2ba>
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
jmp    1384 <main+0x254>
movslq -0x220(%rbp),%rax
movl   $0x1,-0x200(%rbp,%rax,4)
movl   $0x1,-0x224(%rbp)
mov    -0x224(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jg     14f3 <main+0x3c3>
movslq -0x220(%rbp),%rcx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x224(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x22c(%rbp),%eax
jge    14da <main+0x3aa>
movslq -0x224(%rbp),%rax
mov    -0x1d0(%rbp,%rax,4),%eax
movslq -0x220(%rbp),%rcx
mov    -0x1d0(%rbp,%rcx,4),%ecx
movslq -0x220(%rbp),%rsi
lea    -0x1a0(%rbp),%rdx
imul   $0x28,%rsi,%rsi
add    %rsi,%rdx
movslq -0x224(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
cmp    %ecx,%eax
jle    14d5 <main+0x3a5>
movslq -0x220(%rbp),%rax
mov    -0x1d0(%rbp,%rax,4),%ecx
movslq -0x220(%rbp),%rdx
lea    -0x1a0(%rbp),%rax
imul   $0x28,%rdx,%rdx
add    %rdx,%rax
movslq -0x224(%rbp),%rdx
add    (%rax,%rdx,4),%ecx
movslq -0x224(%rbp),%rax
mov    %ecx,-0x1d0(%rbp,%rax,4)
jmp    14da <main+0x3aa>
jmp    14df <main+0x3af>
mov    -0x224(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x224(%rbp)
jmp    141a <main+0x2ea>
jmp    14f8 <main+0x3c8>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    135c <main+0x22c>
movl   $0x1,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jg     1556 <main+0x426>
movslq -0x204(%rbp),%rax
mov    -0x1d0(%rbp,%rax,4),%esi
lea    0xacc(%rip),%rdi
call   1030 <printf@plt>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1516 <main+0x3e6>
mov    $0x0,%al
call   1040 <getchar@plt>
xor    %eax,%eax
add    $0x230,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x210,%rsp
lea    0xe9d(%rip),%rdi
xor    %ebx,%ebx
lea    0xc(%rsp),%rsi
lea    0x10(%rsp),%rdx
xor    %eax,%eax
call   1070 <scanf@plt>
mov    0xc(%rsp),%r14d
test   %r14d,%r14d
jle    127c <main+0x12c>
lea    0x1(%r14),%r8
lea    -0x1(%r14),%r9
mov    %r14d,%r15d
and    $0x3,%r15d
mov    %r14d,%r11d
and    $0xfffffffc,%r11d
lea    0xb8(%rsp),%rdi
lea    0xa8(%rsp),%r10
mov    $0x1,%edx
xor    %r12d,%r12d
jmp    11d9 <main+0x89>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    $0x28,%rdi
add    $0x1,%r12
add    $0x28,%r10
cmp    %r8,%rdx
je     127c <main+0x12c>
mov    $0x1,%ebp
cmp    $0x3,%r9
jb     1248 <main+0xf8>
mov    $0x1,%esi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
cmp    %rbp,%r12
mov    $0x3b9ac9ff,%eax
cmove  %ebx,%eax
mov    %eax,-0xc(%rdi,%rbp,4)
lea    0x1(%rsi),%rax
cmp    %rax,%rdx
mov    $0x3b9ac9ff,%eax
cmove  %ebx,%eax
mov    %eax,-0x8(%rdi,%rbp,4)
lea    0x2(%rsi),%rax
cmp    %rax,%rdx
mov    $0x3b9ac9ff,%eax
cmove  %ebx,%eax
mov    %eax,-0x4(%rdi,%rbp,4)
lea    0x3(%rsi),%rax
cmp    %rax,%rdx
mov    $0x3b9ac9ff,%eax
cmove  %ebx,%eax
mov    %eax,(%rdi,%rbp,4)
add    $0x4,%rsi
add    $0x4,%rbp
cmp    %r11,%rbp
jne    11f0 <main+0xa0>
add    $0x1,%rbp
test   %r15,%r15
je     11c0 <main+0x70>
lea    (%r10,%rbp,4),%rsi
mov    %rdx,%rax
sub    %rbp,%rax
xor    %ebp,%ebp
nopl   (%rax)
cmp    %rbp,%rax
mov    $0x3b9ac9ff,%ecx
cmove  %ebx,%ecx
mov    %ecx,(%rsi,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1260 <main+0x110>
jmp    11c0 <main+0x70>
cmpl   $0x0,0x10(%rsp)
jle    12e1 <main+0x191>
lea    0xd76(%rip),%r14
lea    0x1c(%rsp),%r15
lea    0x18(%rsp),%r12
lea    0x14(%rsp),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    %rbx,%rcx
xor    %eax,%eax
call   1070 <scanf@plt>
mov    0x14(%rsp),%eax
movslq 0x1c(%rsp),%rcx
movslq 0x18(%rsp),%rdx
lea    (%rcx,%rcx,4),%rcx
lea    (%rsp,%rcx,8),%rcx
add    $0x80,%rcx
mov    %eax,(%rcx,%rdx,4)
add    $0x1,%ebp
cmp    0x10(%rsp),%ebp
jl     12a0 <main+0x150>
mov    0xc(%rsp),%r14d
test   %r14d,%r14d
jle    14ca <main+0x37a>
lea    0x24(%rsp),%rdi
lea    0xac(%rsp),%rsi
mov    %r14d,%r12d
lea    0x0(,%r12,4),%r15
mov    %r15,%rdx
call   1060 <memcpy@plt>
lea    0x54(%rsp),%rdi
xor    %ebp,%ebp
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
movl   $0x1,0x54(%rsp)
cmp    $0x1,%r14d
je     14a6 <main+0x356>
lea    -0x1(%r12),%r9
mov    %r12d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
mov    $0x1,%r10d
lea    0x84(%rsp),%r8
jmp    135d <main+0x20d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10d
cmp    %r14d,%r10d
je     14a1 <main+0x351>
mov    $0x3b9ac9ff,%esi
mov    $0x1,%edi
test   %r9,%r9
jne    13c2 <main+0x272>
test   $0x1,%r12b
je     1380 <main+0x230>
cmpl   $0x0,0x50(%rsp,%rdi,4)
jne    1380 <main+0x230>
cmp    %esi,0x20(%rsp,%rdi,4)
cmovl  %edi,%ebp
movslq %ebp,%rsi
movl   $0x1,0x50(%rsp,%rsi,4)
test   %r9,%r9
je     1460 <main+0x310>
lea    (%rsi,%rsi,4),%rax
lea    (%r8,%rax,8),%rbx
mov    $0x1,%edi
jmp    1422 <main+0x2d2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rcx,%rdi,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x1,%rax
je     136c <main+0x21c>
cmpl   $0x0,0x50(%rsp,%rdi,4)
je     13e0 <main+0x290>
cmpl   $0x0,0x54(%rsp,%rdi,4)
jne    13b0 <main+0x260>
jmp    13f3 <main+0x2a3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp,%rdi,4),%eax
cmp    %esi,%eax
cmovl  %edi,%ebp
cmovl  %eax,%esi
cmpl   $0x0,0x54(%rsp,%rdi,4)
jne    13b0 <main+0x260>
mov    0x24(%rsp,%rdi,4),%eax
lea    0x1(%rdi),%ebx
cmp    %esi,%eax
cmovl  %ebx,%ebp
cmovl  %eax,%esi
jmp    13b0 <main+0x260>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rcx,%rdi,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x1,%rax
je     1465 <main+0x315>
mov    -0x4(%rbx,%rdi,4),%eax
cmp    $0x3b9ac9fe,%eax
jg     143e <main+0x2ee>
mov    0x20(%rsp,%rdi,4),%edx
add    0x20(%rsp,%rsi,4),%eax
cmp    %eax,%edx
cmovle %edx,%eax
mov    %eax,0x20(%rsp,%rdi,4)
mov    (%rbx,%rdi,4),%eax
cmp    $0x3b9ac9fe,%eax
jg     1410 <main+0x2c0>
mov    0x24(%rsp,%rdi,4),%edx
add    0x20(%rsp,%rsi,4),%eax
cmp    %eax,%edx
cmovle %edx,%eax
mov    %eax,0x24(%rsp,%rdi,4)
jmp    1410 <main+0x2c0>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%edi
test   $0x1,%r12b
je     1350 <main+0x200>
lea    (%rsi,%rsi,4),%rax
lea    (%rsp,%rax,8),%rax
add    $0x80,%rax
mov    (%rax,%rdi,4),%eax
cmp    $0x3b9ac9fe,%eax
jg     1350 <main+0x200>
mov    0x20(%rsp,%rdi,4),%edx
add    0x20(%rsp,%rsi,4),%eax
cmp    %eax,%edx
cmovle %edx,%eax
mov    %eax,0x20(%rsp,%rdi,4)
jmp    1350 <main+0x200>
test   %r14d,%r14d
jle    14ca <main+0x37a>
xor    %ebp,%ebp
lea    0xb5a(%rip),%rbx
nop
mov    0x24(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
movslq 0xc(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     14b0 <main+0x360>
xor    %eax,%eax
call   1050 <getchar@plt>
xor    %eax,%eax
add    $0x210,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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