#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 */
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *, int *);
int main(void) {
  int **c, a, b, i, j;
  scanf("%d %d", &a, &b);
  c = (int **)malloc(a * a * sizeof(int));
  for (i = 0; i < a; i++) {
    c[i] = (int *)malloc(a * sizeof(int));
  }
  for (i = 0; i < a; i++) {
    for (j = 0; j < a; j++) {
      c[i][j] = 0;
    }
  }
  for (i = 0; i < a; i++) {
    for (j = 0; j < a; j++) {
      printf("%d ", c[i][j]);
    }
    printf("\n");
  }
  int o = 0;
  int h = a, v = a;
  int step = 0;
  int index = 0;
  int total = a * a;
  int x = 0;
  int y = 0;
  while (index < 16) {
    if (o == 0) {
      while (y < h) {
        printf("%d %d\n", x, y);
        c[x][y] = index++;
        y++;
      }
      o = 1;
      v--;
    } else if (o == 1) {
      while (x < v - 1) {
        printf("%d %d\n", x, y);
        c[x][y] = index++;
      }
      o = 2;
      h--;
    } else if (o == 2) {
      while (y > step) {
        printf("%d %d\n", x, y);
        c[x][y] = index++;
      }
      o = 3;
    } else if (o == 3) {
      while (x > step) {
        printf("%d %d\n", x, y);
        c[x][y] = index++;
      }
      o = 0;
      step++;
    }
    printf("h=%d, v=%d\n", h, v);
  }
  for (i = 0; i < a; i++) {
    for (j = 0; j < a; j++) {
      printf("%d ", c[i][j]);
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeba(%rip),%rdi
lea    -0x14(%rbp),%rsi
lea    -0x18(%rbp),%rdx
call   1050 <scanf@plt>
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11aa <main+0x7a>
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1172 <main+0x42>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1208 <main+0xd8>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11f5 <main+0xc5>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c4 <main+0x94>
jmp    11fa <main+0xca>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b1 <main+0x81>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1279 <main+0x149>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    125d <main+0x12d>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xdbe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1222 <main+0xf2>
lea    0xdab(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    120f <main+0xdf>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    1480 <main+0x350>
cmpl   $0x0,-0x24(%rbp)
jne    132c <main+0x1fc>
jmp    12cb <main+0x19b>
mov    -0x40(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1317 <main+0x1e7>
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
lea    0xd26(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12cb <main+0x19b>
movl   $0x1,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1467 <main+0x337>
cmpl   $0x1,-0x24(%rbp)
jne    1398 <main+0x268>
jmp    133b <main+0x20b>
mov    -0x3c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1383 <main+0x253>
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
lea    0xcb1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    133b <main+0x20b>
movl   $0x2,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1462 <main+0x332>
cmpl   $0x2,-0x24(%rbp)
jne    13f6 <main+0x2c6>
jmp    13a7 <main+0x277>
mov    -0x40(%rbp),%eax
cmp    -0x30(%rbp),%eax
jle    13ea <main+0x2ba>
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
lea    0xc4a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13a7 <main+0x277>
movl   $0x3,-0x24(%rbp)
jmp    145d <main+0x32d>
cmpl   $0x3,-0x24(%rbp)
jne    1458 <main+0x328>
jmp    1405 <main+0x2d5>
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jle    1448 <main+0x318>
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
lea    0xbec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1405 <main+0x2d5>
movl   $0x0,-0x24(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    145d <main+0x32d>
jmp    1462 <main+0x332>
jmp    1467 <main+0x337>
mov    -0x28(%rbp),%esi
mov    -0x2c(%rbp),%edx
lea    0xb9d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    12b2 <main+0x182>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14f1 <main+0x3c1>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14d5 <main+0x3a5>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xb46(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    149a <main+0x36a>
lea    0xb33(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1487 <main+0x357>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
lea    0xebb(%rip),%rdi
lea    0xc(%rsp),%rsi
lea    0x14(%rsp),%rdx
call   1060 <scanf@plt>
mov    0xc(%rsp),%edi
imul   %edi,%edi
shl    $0x2,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    0xc(%rsp),%ebx
test   %ebx,%ebx
jle    1251 <main+0x111>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
shl    $0x2,%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,(%r14,%rbp,8)
add    $0x1,%rbp
movslq 0xc(%rsp),%rbx
cmp    %rbx,%rbp
jl     1190 <main+0x50>
test   %ebx,%ebx
jle    1251 <main+0x111>
xor    %eax,%eax
jmp    11cc <main+0x8c>
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rcx
add    $0x1,%rax
cmp    %rcx,%rax
jge    11f7 <main+0xb7>
test   %ebx,%ebx
jle    11c0 <main+0x80>
mov    (%r14,%rax,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,(%rcx,%rdx,4)
add    $0x1,%rdx
movslq 0xc(%rsp),%rbx
cmp    %rbx,%rdx
jl     11e0 <main+0xa0>
jmp    11c0 <main+0x80>
test   %ebx,%ebx
jle    1251 <main+0x111>
lea    0xe14(%rip),%r15
xor    %ebp,%ebp
jmp    1228 <main+0xe8>
cs nopw 0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
movslq 0xc(%rsp),%rbx
cmp    %rbx,%rbp
jge    1251 <main+0x111>
test   %ebx,%ebx
jle    1210 <main+0xd0>
xor    %ebx,%ebx
xchg   %ax,%ax
mov    (%r14,%rbp,8),%rax
mov    (%rax,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1230 <main+0xf0>
jmp    1210 <main+0xd0>
xor    %r13d,%r13d
xor    %r15d,%r15d
movl   $0x0,0x10(%rsp)
mov    %ebx,%r12d
xor    %ebp,%ebp
jmp    129d <main+0x15d>
cs nopw 0x0(%rax,%rax,1)
mov    $0x3,%ebp
cmp    0x10(%rsp),%r13d
jg     13a2 <main+0x262>
lea    0xd9a(%rip),%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <printf@plt>
cmp    $0x10,%r15d
jge    133a <main+0x1fa>
cmp    $0x3,%ebp
ja     1280 <main+0x140>
mov    %ebp,%eax
lea    0xd55(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmp    %r12d,%r13d
jge    12f5 <main+0x1b5>
movslq %r13d,%rbp
lea    0xd57(%rip),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rdi
xor    %esi,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r14),%rax
mov    %r15d,(%rax,%rbp,4)
add    $0x1,%r15d
add    $0x1,%rbp
cmp    %ebp,%r12d
jne    12d0 <main+0x190>
mov    %r12d,%r13d
add    $0xffffffff,%ebx
mov    $0x1,%ebp
jmp    1280 <main+0x140>
nop
cmp    $0x2,%ebx
jge    13cc <main+0x28c>
add    $0xffffffff,%r12d
mov    $0x2,%ebp
jmp    1280 <main+0x140>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%eax
test   %eax,%eax
js     13fc <main+0x2bc>
add    $0x1,%eax
mov    %eax,0x10(%rsp)
xor    %ebp,%ebp
jmp    1280 <main+0x140>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1391 <main+0x251>
lea    0xccd(%rip),%r15
xor    %ebp,%ebp
jmp    1368 <main+0x228>
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
movslq 0xc(%rsp),%rax
cmp    %rax,%rbp
jge    1391 <main+0x251>
test   %eax,%eax
jle    1350 <main+0x210>
xor    %ebx,%ebx
xchg   %ax,%ax
mov    (%r14,%rbp,8),%rax
mov    (%rax,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1370 <main+0x230>
jmp    1350 <main+0x210>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movslq %r13d,%rbp
lea    0xc6e(%rip),%rbx
nopl   0x0(%rax)
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r14),%rax
mov    %r15d,(%rax,%rbp,4)
add    $0x1,%r15d
jmp    13b0 <main+0x270>
movslq %r13d,%rbp
lea    0xc44(%rip),%rbx
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r14),%rax
mov    %r15d,(%rax,%rbp,4)
add    $0x1,%r15d
jmp    13e0 <main+0x2a0>
movslq %r13d,%rbx
lea    0xc14(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,%rdi
xor    %esi,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r14),%rax
mov    %r15d,(%rax,%rbx,4)
add    $0x1,%r15d
jmp    1410 <main+0x2d0>

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

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