#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*/ exit(int);
scalar_t__ malloc(int);
int **my_malloc(int, int);
int my_req(int, int, int **, int *, int *);
int /*<<< orphan*/ perror(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int security(int, int, int *, int **, int **);
int main(void) {
  int n = 0;
  int m = 0;
  int *all = NULL;
  int **max = NULL;
  int **allocation = NULL;
  int i = 0;
  int j = 0;
  int k = 0;
  int *available = NULL;
  int **need = NULL;
  int flag = 0;
  int *req = NULL;
  int **pre_alloc = NULL;
  int p_num = 0;
  printf("输入进程个数：");
  scanf("%d", &n);
  printf("输入资源个数：");
  scanf("%d", &m);
  if ((all = (int *)malloc(m * sizeof(int))) == NULL) {
    perror("malloc all error");
    exit(1);
  }
  if ((available = (int *)malloc(m * sizeof(int))) == NULL) {
    perror("malloc available error");
    exit(1);
  }
  if ((req = (int *)malloc(m * sizeof(int))) == NULL) {
    perror("malloc req error");
    exit(1);
  }
  max = my_malloc(n, m);
  allocation = my_malloc(n, m);
  need = my_malloc(n, m);
  pre_alloc = my_malloc(n, m);
  printf("输入每类资源的最大数量：\n");
  for (i = 0; i < m; i++) {
    scanf("%d", all + i);
  }
  printf("输入进程的最大需求矩阵：\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < m; j++) {
      scanf("%d", &max[i][j]);
    }
    for (k = 0; k < m; k++) {
      if (max[i][k] > all[k]) {
        printf("输入有误！%d > %d\n", max[i][k], all[k]);
        exit(1);
      }
    }
  }
  printf("输入进程的已分配资源矩阵：\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < m; j++) {
      scanf("%d", &allocation[i][j]);
    }
    for (k = 0; k < m; k++) {
      if (allocation[i][k] > max[i][k]) {
        printf("输入有误！%d > %d\n", allocation[i][k], max[i][k]);
        exit(1);
      }
    }
  }
  for (i = 0; i < m; i++) {
    available[i] = all[i];
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < m; j++) {
      available[j] = available[j] - allocation[i][j];
      if (available[j] < 0) {
        printf("可用资源不足\n");
        exit(1);
      }
    }
  }
  printf("当前时刻的可利用资源:\n");
  for (i = 0; i < m; i++) {
    printf("%d ", available[i]);
  }
  printf("\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < m; j++) {
      need[i][j] = max[i][j] - allocation[i][j];
    }
  }
  printf("当前时刻n个进程的还需要资源:\n");
  for (i = 0; i < n; i++) {
    printf("p%d: ", i);
    for (j = 0; j < m; j++) {
      printf("%d ", need[i][j]);
    }
    printf("\n");
  }
  if (security(n, m, available, need, allocation) == 1) {
    printf("初始状态安全!\n");
  } else {
    printf("初始状态不安全!\n");
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < m; j++) {
      pre_alloc[i][j] = allocation[i][j];
    }
  }
  while (1) {
    if ((p_num = my_req(n, m, need, available, req)) == -1) {
      continue;
    }
    for (i = 0; i < m; i++) {
      pre_alloc[p_num][i] = req[i] + allocation[p_num][i];
      available[i] -= req[i];
      need[p_num][i] -= req[i];
    }
    if (security(n, m, available, need, pre_alloc) == 1) {
      printf("此次资源分配安全!\n");
      for (i = 0; i < m; i++) {
        allocation[p_num][i] = pre_alloc[p_num][i];
      }
    } else {
      printf("此次资源分配不安全!取消分配!\n");
      for (i = 0; i < m; i++) {
        pre_alloc[p_num][i] = allocation[p_num][i];
        available[i] += req[i];
        need[p_num][i] += req[i];
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movq   $0x0,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
lea    0xe01(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe09(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1070 <scanf@plt>
lea    0xdfc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xdeb(%rip),%rdi
lea    -0xc(%rbp),%rsi
call   1070 <scanf@plt>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
jne    1267 <main+0xe7>
lea    0xdd7(%rip),%rdi
call   1080 <perror@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jne    129a <main+0x11a>
lea    0xdb5(%rip),%rdi
call   1080 <perror@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmp    $0x0,%rax
jne    12cd <main+0x14d>
lea    0xd99(%rip),%rdi
call   1080 <perror@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
call   1030 <my_malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
call   1030 <my_malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
call   1030 <my_malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
call   1030 <my_malloc@plt>
mov    %rax,-0x60(%rbp)
lea    0xd58(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1353 <main+0x1d3>
mov    -0x18(%rbp),%rsi
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xcd6(%rip),%rdi
call   1070 <scanf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    131e <main+0x19e>
lea    0xd34(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    144b <main+0x2cb>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13b8 <main+0x238>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x30(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xc71(%rip),%rdi
call   1070 <scanf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    137b <main+0x1fb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1438 <main+0x2b8>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1425 <main+0x2a5>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xca0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
jmp    142a <main+0x2aa>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13bf <main+0x23f>
jmp    143d <main+0x2bd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1368 <main+0x1e8>
lea    0xc7a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1553 <main+0x3d3>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14b0 <main+0x330>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x30(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xb79(%rip),%rdi
call   1070 <scanf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1473 <main+0x2f3>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1540 <main+0x3c0>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    152d <main+0x3ad>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xb98(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
jmp    1532 <main+0x3b2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14b7 <main+0x337>
jmp    1545 <main+0x3c5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1460 <main+0x2e0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    158a <main+0x40a>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    155a <main+0x3da>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1629 <main+0x4a9>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1616 <main+0x496>
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1603 <main+0x483>
lea    0xb03(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
jmp    1608 <main+0x488>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15a4 <main+0x424>
jmp    161b <main+0x49b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1591 <main+0x411>
lea    0xad9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1671 <main+0x4f1>
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xace(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    163e <main+0x4be>
lea    0xb58(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16ff <main+0x57f>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16ec <main+0x56c>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1699 <main+0x519>
jmp    16f1 <main+0x571>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1686 <main+0x506>
lea    0xa28(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    178f <main+0x60f>
mov    -0x2c(%rbp),%esi
lea    0xa2f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1773 <main+0x5f3>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x9cc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1738 <main+0x5b8>
lea    0xa56(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1714 <main+0x594>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x40(%rbp),%rdx
mov    -0x48(%rbp),%rcx
mov    -0x28(%rbp),%r8
call   1090 <security@plt>
cmp    $0x1,%eax
jne    17c2 <main+0x642>
lea    0x9a9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    17d0 <main+0x650>
lea    0x9ab(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    183d <main+0x6bd>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    182a <main+0x6aa>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17ea <main+0x66a>
jmp    182f <main+0x6af>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17d7 <main+0x657>
jmp    1842 <main+0x6c2>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0x58(%rbp),%r8
call   1050 <my_req@plt>
mov    %eax,-0x64(%rbp)
cmp    $0xffffffff,%eax
jne    186a <main+0x6ea>
jmp    1842 <main+0x6c2>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18fa <main+0x77a>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1871 <main+0x6f1>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x40(%rbp),%rdx
mov    -0x48(%rbp),%rcx
mov    -0x60(%rbp),%r8
call   1090 <security@plt>
cmp    $0x1,%eax
jne    1974 <main+0x7f4>
lea    0x86b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    196f <main+0x7ef>
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    192f <main+0x7af>
jmp    1a08 <main+0x888>
lea    0x82c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a03 <main+0x883>
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1989 <main+0x809>
jmp    1a08 <main+0x888>
jmp    1842 <main+0x6c2>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
movl   $0x0,0xc(%rsp)
movl   $0x0,0x8(%rsp)
lea    0xe3b(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe43(%rip),%rbx
lea    0xc(%rsp),%rsi
mov    %rbx,%rdi
call   1090 <scanf@plt>
lea    0xe32(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x8(%rsp),%rsi
mov    %rbx,%rdi
call   1090 <scanf@plt>
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1080 <malloc@plt>
mov    %rax,0x18(%rsp)
test   %rax,%rax
je     1814 <main+0x674>
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     181d <main+0x67d>
mov    %rax,%r14
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     1826 <main+0x686>
mov    %rax,%rbx
mov    0xc(%rsp),%edi
mov    0x8(%rsp),%esi
call   1030 <my_malloc@plt>
mov    %rax,0x10(%rsp)
mov    0xc(%rsp),%edi
mov    0x8(%rsp),%esi
call   1030 <my_malloc@plt>
mov    %rax,0x20(%rsp)
mov    0xc(%rsp),%edi
mov    0x8(%rsp),%esi
call   1030 <my_malloc@plt>
mov    %rax,%r12
mov    0xc(%rsp),%edi
mov    0x8(%rsp),%esi
call   1030 <my_malloc@plt>
mov    %rax,%r13
lea    0xdfa(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    12d1 <main+0x131>
xor    %r15d,%r15d
mov    0x18(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0xd5f(%rip),%rdi
mov    %rbp,%rsi
call   1090 <scanf@plt>
add    $0x1,%r15
movslq 0x8(%rsp),%rax
add    $0x4,%rbp
cmp    %rax,%r15
jl     12b0 <main+0x110>
lea    0xdd7(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,0xc(%rsp)
mov    0x10(%rsp),%r10
mov    %r13,0x30(%rsp)
mov    %r12,0x28(%rsp)
jle    13ad <main+0x20d>
mov    0x8(%rsp),%r11d
xor    %eax,%eax
lea    0xd11(%rip),%rdi
jmp    132c <main+0x18c>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%r13
mov    0x28(%rsp),%r12
add    $0x1,%rax
movslq 0xc(%rsp),%rcx
cmp    %rcx,%rax
jge    13ad <main+0x20d>
test   %r11d,%r11d
jle    131a <main+0x17a>
xor    %r15d,%r15d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    (%r10,%rax,8),%rsi
add    %r15,%rsi
mov    %rax,%r13
mov    %rdi,%r12
call   1090 <scanf@plt>
mov    %r12,%rdi
mov    %r13,%rax
mov    0x10(%rsp),%r10
add    $0x1,%rbp
movslq 0x8(%rsp),%r11
add    $0x4,%r15
cmp    %r11,%rbp
jl     1340 <main+0x1a0>
test   %r11d,%r11d
mov    0x18(%rsp),%r9
jle    1310 <main+0x170>
mov    %r11d,%r8d
mov    (%r10,%rax,8),%rcx
xor    %ebp,%ebp
mov    0x30(%rsp),%r13
mov    0x28(%rsp),%r12
nopl   0x0(%rax)
mov    (%rcx,%rbp,4),%esi
mov    (%r9,%rbp,4),%edx
cmp    %edx,%esi
jg     17e6 <main+0x646>
add    $0x1,%rbp
cmp    %rbp,%r8
jne    1390 <main+0x1f0>
jmp    131a <main+0x17a>
lea    0xd20(%rip),%rdi
call   1050 <puts@plt>
mov    0xc(%rsp),%ecx
mov    0x8(%rsp),%r11d
test   %ecx,%ecx
jle    148e <main+0x2ee>
xor    %eax,%eax
lea    0xc43(%rip),%rdi
mov    0x18(%rsp),%r9
jmp    1401 <main+0x261>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%r13
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r12
add    $0x1,%rax
movslq 0xc(%rsp),%rcx
cmp    %rcx,%rax
jge    1493 <main+0x2f3>
test   %r11d,%r11d
jle    13ef <main+0x24f>
xor    %ebp,%ebp
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rsi
add    %rbp,%rsi
mov    %rax,%r13
mov    %rdi,%r12
call   1090 <scanf@plt>
mov    %r12,%rdi
mov    %r13,%rax
add    $0x1,%r15
movslq 0x8(%rsp),%r11
add    $0x4,%rbp
cmp    %r11,%r15
jl     1410 <main+0x270>
test   %r11d,%r11d
jle    13e0 <main+0x240>
mov    %r11d,%r8d
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%r10
mov    0x10(%rsp),%rcx
mov    (%rcx,%rax,8),%rbp
xor    %ecx,%ecx
mov    0x30(%rsp),%r13
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r12
nopw   0x0(%rax,%rax,1)
mov    (%r10,%rcx,4),%esi
mov    0x0(%rbp,%rcx,4),%edx
cmp    %edx,%esi
jg     17e6 <main+0x646>
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1470 <main+0x2d0>
jmp    13ef <main+0x24f>
mov    0x18(%rsp),%r9
test   %r11d,%r11d
mov    0x20(%rsp),%rbp
jle    14ba <main+0x31a>
xor    %ecx,%ecx
nop
mov    (%r9,%rcx,4),%eax
mov    %eax,(%r14,%rcx,4)
add    $0x1,%rcx
movslq 0x8(%rsp),%r11
cmp    %r11,%rcx
jl     14a0 <main+0x300>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jle    1511 <main+0x371>
xor    %edx,%edx
jmp    14dc <main+0x33c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
movslq %ecx,%rsi
cmp    %rsi,%rdx
jge    1511 <main+0x371>
test   %r11d,%r11d
jle    14d0 <main+0x330>
mov    0x0(%rbp,%rdx,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rsi,4),%eax
sub    %eax,(%r14,%rsi,4)
js     17fe <main+0x65e>
add    $0x1,%rsi
movslq 0x8(%rsp),%r11
cmp    %r11,%rsi
jl     14f0 <main+0x350>
mov    0xc(%rsp),%ecx
jmp    14d0 <main+0x330>
lea    0xbe4(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    154c <main+0x3ac>
lea    0xb55(%rip),%r15
xor    %ebp,%ebp
nopl   (%rax)
mov    (%r14,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     1530 <main+0x390>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0xc(%rsp),%edx
test   %edx,%edx
mov    0x20(%rsp),%r15
mov    0x10(%rsp),%r8
jle    15ad <main+0x40d>
mov    0x8(%rsp),%ecx
xor    %eax,%eax
jmp    157c <main+0x3dc>
add    $0x1,%rax
movslq %edx,%rsi
cmp    %rsi,%rax
jge    15ad <main+0x40d>
test   %ecx,%ecx
jle    1570 <main+0x3d0>
mov    (%r8,%rax,8),%rdx
mov    (%r15,%rax,8),%rsi
mov    (%r12,%rax,8),%rdi
xor    %ebp,%ebp
xchg   %ax,%ax
mov    (%rdx,%rbp,4),%ecx
sub    (%rsi,%rbp,4),%ecx
mov    %ecx,(%rdi,%rbp,4)
add    $0x1,%rbp
movslq 0x8(%rsp),%rcx
cmp    %rcx,%rbp
jl     1590 <main+0x3f0>
mov    0xc(%rsp),%edx
jmp    1570 <main+0x3d0>
lea    0xb68(%rip),%rdi
call   1050 <puts@plt>
mov    0xc(%rsp),%edi
test   %edi,%edi
jle    164b <main+0x4ab>
xor    %eax,%eax
jmp    15ed <main+0x44d>
nopl   0x0(%rax)
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x10(%rsp),%rax
add    $0x1,%rax
movslq 0xc(%rsp),%rdi
cmp    %rdi,%rax
jge    1646 <main+0x4a6>
lea    0xa90(%rip),%rdi
mov    %rax,%rsi
mov    %rax,0x10(%rsp)
xor    %eax,%eax
call   1060 <printf@plt>
cmpl   $0x0,0x8(%rsp)
lea    0xa71(%rip),%r15
jle    15d0 <main+0x430>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x10(%rsp),%rax
mov    (%r12,%rax,8),%rax
mov    (%rax,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     1620 <main+0x480>
jmp    15d0 <main+0x430>
mov    0x20(%rsp),%r15
mov    0x8(%rsp),%esi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %r15,%r8
call   10b0 <security@plt>
cmp    $0x1,%eax
lea    0xb3a(%rip),%rax
lea    0xad8(%rip),%rdi
cmove  %rax,%rdi
call   1050 <puts@plt>
mov    0xc(%rsp),%edi
test   %edi,%edi
jle    16d4 <main+0x534>
mov    0x8(%rsp),%ecx
xor    %eax,%eax
jmp    169c <main+0x4fc>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
movslq %edi,%rdx
cmp    %rdx,%rax
jge    16d4 <main+0x534>
test   %ecx,%ecx
jle    1690 <main+0x4f0>
mov    (%r15,%rax,8),%rdx
mov    0x0(%r13,%rax,8),%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rdi,4),%ecx
mov    %ecx,(%rsi,%rdi,4)
add    $0x1,%rdi
movslq 0x8(%rsp),%rcx
cmp    %rcx,%rdi
jl     16b0 <main+0x510>
mov    0xc(%rsp),%edi
jmp    1690 <main+0x4f0>
nopw   0x0(%rax,%rax,1)
mov    0xc(%rsp),%edi
mov    0x8(%rsp),%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %rbx,%r8
call   1070 <my_req@plt>
cmp    $0xffffffff,%eax
je     16d0 <main+0x530>
mov    %eax,%ebp
mov    0x8(%rsp),%esi
test   %esi,%esi
jle    1734 <main+0x594>
movslq %ebp,%rdx
mov    (%r15,%rdx,8),%rax
mov    0x0(%r13,%rdx,8),%rcx
mov    (%r12,%rdx,8),%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rdi,4),%esi
add    (%rbx,%rdi,4),%esi
mov    %esi,(%rcx,%rdi,4)
mov    (%rbx,%rdi,4),%esi
sub    %esi,(%r14,%rdi,4)
mov    (%rbx,%rdi,4),%esi
sub    %esi,(%rdx,%rdi,4)
add    $0x1,%rdi
movslq 0x8(%rsp),%rsi
cmp    %rsi,%rdi
jl     1710 <main+0x570>
mov    0xc(%rsp),%edi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %r13,%r8
call   10b0 <security@plt>
cmp    $0x1,%eax
jne    1790 <main+0x5f0>
lea    0xa35(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    16d0 <main+0x530>
movslq %ebp,%rcx
mov    0x0(%r13,%rcx,8),%rax
mov    (%r15,%rcx,8),%rcx
xor    %edx,%edx
mov    (%rax,%rdx,4),%esi
mov    %esi,(%rcx,%rdx,4)
add    $0x1,%rdx
movslq 0x8(%rsp),%rsi
cmp    %rsi,%rdx
jl     1770 <main+0x5d0>
jmp    16d0 <main+0x530>
nopl   0x0(%rax)
lea    0x9c6(%rip),%rdi
call   1050 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    16d0 <main+0x530>
movslq %ebp,%rdx
mov    (%r15,%rdx,8),%rax
mov    0x0(%r13,%rdx,8),%rcx
mov    (%r12,%rdx,8),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
mov    (%rax,%rsi,4),%edi
mov    %edi,(%rcx,%rsi,4)
mov    (%rbx,%rsi,4),%edi
add    %edi,(%r14,%rsi,4)
mov    (%rbx,%rsi,4),%edi
add    %edi,(%rdx,%rsi,4)
add    $0x1,%rsi
movslq 0x8(%rsp),%rdi
cmp    %rdi,%rsi
jl     17c0 <main+0x620>
jmp    16d0 <main+0x530>
lea    0x87b(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x1,%edi
call   10c0 <exit@plt>
lea    0x9b0(%rip),%rdi
call   1050 <puts@plt>
mov    $0x1,%edi
call   10c0 <exit@plt>
lea    0x814(%rip),%rdi
jmp    182d <main+0x68d>
lea    0x81c(%rip),%rdi
jmp    182d <main+0x68d>
lea    0x82a(%rip),%rdi
call   10a0 <perror@plt>
mov    $0x1,%edi
call   10c0 <exit@plt>

LLVM IR (-O0):
@.str = [22 x i8] c"\E8\BE\93\E5\85\A5\E8\BF\9B\E7\A8\8B\E4\B8\AA\E6\95\B0\EF\BC\9A\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [22 x i8] c"\E8\BE\93\E5\85\A5\E8\B5\84\E6\BA\90\E4\B8\AA\E6\95\B0\EF\BC\9A\00"
@.str.3 = [17 x i8] c"malloc all error\00"
@.str.4 = [23 x i8] c"malloc available error\00"
@.str.5 = [17 x i8] c"malloc req error\00"
@.str.6 = [38 x i8] c"\E8\BE\93\E5\85\A5\E6\AF\8F\E7\B1\BB\E8\B5\84\E6\BA\90\E7\9A\84\E6\9C\80\E5\A4\A7\E6\95\B0\E9\87\8F\EF\BC\9A\0A\00"
@.str.7 = [38 x i8] c"\E8\BE\93\E5\85\A5\E8\BF\9B\E7\A8\8B\E7\9A\84\E6\9C\80\E5\A4\A7\E9\9C\80\E6\B1\82\E7\9F\A9\E9\98\B5\EF\BC\9A\0A\00"
@.str.8 = [24 x i8] c"\E8\BE\93\E5\85\A5\E6\9C\89\E8\AF\AF\EF\BC\81%d > %d\0A\00"
@.str.9 = [41 x i8] c"\E8\BE\93\E5\85\A5\E8\BF\9B\E7\A8\8B\E7\9A\84\E5\B7\B2\E5\88\86\E9\85\8D\E8\B5\84\E6\BA\90\E7\9F\A9\E9\98\B5\EF\BC\9A\0A\00"
@.str.10 = [20 x i8] c"\E5\8F\AF\E7\94\A8\E8\B5\84\E6\BA\90\E4\B8\8D\E8\B6\B3\0A\00"
@.str.11 = [33 x i8] c"\E5\BD\93\E5\89\8D\E6\97\B6\E5\88\BB\E7\9A\84\E5\8F\AF\E5\88\A9\E7\94\A8\E8\B5\84\E6\BA\90:\0A\00"
@.str.12 = [4 x i8] c"%d \00"
@.str.13 = [2 x i8] c"\0A\00"
@.str.14 = [43 x i8] c"\E5\BD\93\E5\89\8D\E6\97\B6\E5\88\BBn\E4\B8\AA\E8\BF\9B\E7\A8\8B\E7\9A\84\E8\BF\98\E9\9C\80\E8\A6\81\E8\B5\84\E6\BA\90:\0A\00"
@.str.15 = [6 x i8] c"p%d: \00"
@.str.16 = [21 x i8] c"\E5\88\9D\E5\A7\8B\E7\8A\B6\E6\80\81\E5\AE\89\E5\85\A8!\0A\00"
@.str.17 = [24 x i8] c"\E5\88\9D\E5\A7\8B\E7\8A\B6\E6\80\81\E4\B8\8D\E5\AE\89\E5\85\A8!\0A\00"
@.str.18 = [27 x i8] c"\E6\AD\A4\E6\AC\A1\E8\B5\84\E6\BA\90\E5\88\86\E9\85\8D\E5\AE\89\E5\85\A8!\0A\00"
@.str.19 = [43 x i8] c"\E6\AD\A4\E6\AC\A1\E8\B5\84\E6\BA\90\E5\88\86\E9\85\8D\E4\B8\8D\E5\AE\89\E5\85\A8!\E5\8F\96\E6\B6\88\E5\88\86\E9\85\8D!\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**
%15 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %2
store i32 0, i32* %3
store i32* null, i32** %4
store i32** null, i32*** %5
store i32** null, i32*** %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
store i32* null, i32** %10
store i32** null, i32*** %11
store i32 0, i32* %12
store i32* null, i32** %13
store i32** null, i32*** %14
store i32 0, i32* %15
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
%17 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0))
%19 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %3)
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 4
%23 = trunc i64 %22 to i32
%24 = call i64 @malloc(i32 %23)
%25 = inttoptr i64 %24 to i32*
store i32* %25, i32** %4
%26 = icmp eq i32* %25, null
br i1 %26, label %27, label %30
27: ; preds = %0
%28 = call i32 @perror(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0))
%29 = call i32 @exit(i32 1)
unreachable
30: ; preds = %0
%31 = load i32, i32* %3
%32 = sext i32 %31 to i64
%33 = mul i64 %32, 4
%34 = trunc i64 %33 to i32
%35 = call i64 @malloc(i32 %34)
%36 = inttoptr i64 %35 to i32*
store i32* %36, i32** %10
%37 = icmp eq i32* %36, null
br i1 %37, label %38, label %41
38: ; preds = %30
%39 = call i32 @perror(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0))
%40 = call i32 @exit(i32 1)
unreachable
41: ; preds = %30
%42 = load i32, i32* %3
%43 = sext i32 %42 to i64
%44 = mul i64 %43, 4
%45 = trunc i64 %44 to i32
%46 = call i64 @malloc(i32 %45)
%47 = inttoptr i64 %46 to i32*
store i32* %47, i32** %13
%48 = icmp eq i32* %47, null
br i1 %48, label %49, label %52
49: ; preds = %41
%50 = call i32 @perror(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0))
%51 = call i32 @exit(i32 1)
unreachable
52: ; preds = %41
%53 = load i32, i32* %2
%54 = load i32, i32* %3
%55 = call i32** @my_malloc(i32 %53, i32 %54)
store i32** %55, i32*** %5
%56 = load i32, i32* %2
%57 = load i32, i32* %3
%58 = call i32** @my_malloc(i32 %56, i32 %57)
store i32** %58, i32*** %6
%59 = load i32, i32* %2
%60 = load i32, i32* %3
%61 = call i32** @my_malloc(i32 %59, i32 %60)
store i32** %61, i32*** %11
%62 = load i32, i32* %2
%63 = load i32, i32* %3
%64 = call i32** @my_malloc(i32 %62, i32 %63)
store i32** %64, i32*** %14
%65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %7
br label %66
66: ; preds = %76, %52
%67 = load i32, i32* %7
%68 = load i32, i32* %3
%69 = icmp slt i32 %67, %68
br i1 %69, label %70, label %79
70: ; preds = %66
%71 = load i32*, i32** %4
%72 = load i32, i32* %7
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %71, i64 %73
%75 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %74)
br label %76
76: ; preds = %70
%77 = load i32, i32* %7
%78 = add nsw i32 %77, 1
store i32 %78, i32* %7
br label %66
79: ; preds = %66
%80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %7
br label %81
81: ; preds = %146, %79
%82 = load i32, i32* %7
%83 = load i32, i32* %2
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %149
85: ; preds = %81
store i32 0, i32* %8
br label %86
86: ; preds = %100, %85
%87 = load i32, i32* %8
%88 = load i32, i32* %3
%89 = icmp slt i32 %87, %88
br i1 %89, label %90, label %103
90: ; preds = %86
%91 = load i32**, i32*** %5
%92 = load i32, i32* %7
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32*, i32** %91, i64 %93
%95 = load i32*, i32** %94
%96 = load i32, i32* %8
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %95, i64 %97
%99 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %98)
br label %100
100: ; preds = %90
%101 = load i32, i32* %8
%102 = add nsw i32 %101, 1
store i32 %102, i32* %8
br label %86
103: ; preds = %86
store i32 0, i32* %9
br label %104
104: ; preds = %142, %103
%105 = load i32, i32* %9
%106 = load i32, i32* %3
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %145
108: ; preds = %104
%109 = load i32**, i32*** %5
%110 = load i32, i32* %7
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i32*, i32** %109, i64 %111
%113 = load i32*, i32** %112
%114 = load i32, i32* %9
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %113, i64 %115
%117 = load i32, i32* %116
%118 = load i32*, i32** %4
%119 = load i32, i32* %9
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32, i32* %118, i64 %120
%122 = load i32, i32* %121
%123 = icmp sgt i32 %117, %122
br i1 %123, label %124, label %141
124: ; preds = %108
%125 = load i32**, i32*** %5
%126 = load i32, i32* %7
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i32*, i32** %125, i64 %127
%129 = load i32*, i32** %128
%130 = load i32, i32* %9
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32, i32* %129, i64 %131
%133 = load i32, i32* %132
%134 = load i32*, i32** %4
%135 = load i32, i32* %9
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %134, i64 %136
%138 = load i32, i32* %137
%139 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.8, i64 0, i64 0), i32 %133, i32 %138)
%140 = call i32 @exit(i32 1)
unreachable
141: ; preds = %108
br label %142
142: ; preds = %141
%143 = load i32, i32* %9
%144 = add nsw i32 %143, 1
store i32 %144, i32* %9
br label %104
145: ; preds = %104
br label %146
146: ; preds = %145
%147 = load i32, i32* %7
%148 = add nsw i32 %147, 1
store i32 %148, i32* %7
br label %81
149: ; preds = %81
%150 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %7
br label %151
151: ; preds = %224, %149
%152 = load i32, i32* %7
%153 = load i32, i32* %2
%154 = icmp slt i32 %152, %153
br i1 %154, label %155, label %227
155: ; preds = %151
store i32 0, i32* %8
br label %156
156: ; preds = %170, %155
%157 = load i32, i32* %8
%158 = load i32, i32* %3
%159 = icmp slt i32 %157, %158
br i1 %159, label %160, label %173
160: ; preds = %156
%161 = load i32**, i32*** %6
%162 = load i32, i32* %7
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i32*, i32** %161, i64 %163
%165 = load i32*, i32** %164
%166 = load i32, i32* %8
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %165, i64 %167
%169 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %168)
br label %170
170: ; preds = %160
%171 = load i32, i32* %8
%172 = add nsw i32 %171, 1
store i32 %172, i32* %8
br label %156
173: ; preds = %156
store i32 0, i32* %9
br label %174
174: ; preds = %220, %173
%175 = load i32, i32* %9
%176 = load i32, i32* %3
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %223
178: ; preds = %174
%179 = load i32**, i32*** %6
%180 = load i32, i32* %7
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32*, i32** %179, i64 %181
%183 = load i32*, i32** %182
%184 = load i32, i32* %9
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %183, i64 %185
%187 = load i32, i32* %186
%188 = load i32**, i32*** %5
%189 = load i32, i32* %7
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32*, i32** %188, i64 %190
%192 = load i32*, i32** %191
%193 = load i32, i32* %9
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32, i32* %192, i64 %194
%196 = load i32, i32* %195
%197 = icmp sgt i32 %187, %196
br i1 %197, label %198, label %219
198: ; preds = %178
%199 = load i32**, i32*** %6
%200 = load i32, i32* %7
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i32*, i32** %199, i64 %201
%203 = load i32*, i32** %202
%204 = load i32, i32* %9
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %203, i64 %205
%207 = load i32, i32* %206
%208 = load i32**, i32*** %5
%209 = load i32, i32* %7
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32*, i32** %208, i64 %210
%212 = load i32*, i32** %211
%213 = load i32, i32* %9
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i32, i32* %212, i64 %214
%216 = load i32, i32* %215
%217 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.8, i64 0, i64 0), i32 %207, i32 %216)
%218 = call i32 @exit(i32 1)
unreachable
219: ; preds = %178
br label %220
220: ; preds = %219
%221 = load i32, i32* %9
%222 = add nsw i32 %221, 1
store i32 %222, i32* %9
br label %174
223: ; preds = %174
br label %224
224: ; preds = %223
%225 = load i32, i32* %7
%226 = add nsw i32 %225, 1
store i32 %226, i32* %7
br label %151
227: ; preds = %151
store i32 0, i32* %7
br label %228
228: ; preds = %242, %227
%229 = load i32, i32* %7
%230 = load i32, i32* %3
%231 = icmp slt i32 %229, %230
br i1 %231, label %232, label %245
232: ; preds = %228
%233 = load i32*, i32** %4
%234 = load i32, i32* %7
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i32, i32* %233, i64 %235
%237 = load i32, i32* %236
%238 = load i32*, i32** %10
%239 = load i32, i32* %7
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i32, i32* %238, i64 %240
store i32 %237, i32* %241
br label %242
242: ; preds = %232
%243 = load i32, i32* %7
%244 = add nsw i32 %243, 1
store i32 %244, i32* %7
br label %228
245: ; preds = %228
store i32 0, i32* %7
br label %246
246: ; preds = %289, %245
%247 = load i32, i32* %7
%248 = load i32, i32* %2
%249 = icmp slt i32 %247, %248
br i1 %249, label %250, label %292
250: ; preds = %246
store i32 0, i32* %8
br label %251
251: ; preds = %285, %250
%252 = load i32, i32* %8
%253 = load i32, i32* %3
%254 = icmp slt i32 %252, %253
br i1 %254, label %255, label %288
255: ; preds = %251
%256 = load i32*, i32** %10
%257 = load i32, i32* %8
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i32, i32* %256, i64 %258
%260 = load i32, i32* %259
%261 = load i32**, i32*** %6
%262 = load i32, i32* %7
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32*, i32** %261, i64 %263
%265 = load i32*, i32** %264
%266 = load i32, i32* %8
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %265, i64 %267
%269 = load i32, i32* %268
%270 = sub nsw i32 %260, %269
%271 = load i32*, i32** %10
%272 = load i32, i32* %8
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds i32, i32* %271, i64 %273
store i32 %270, i32* %274
%275 = load i32*, i32** %10
%276 = load i32, i32* %8
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds i32, i32* %275, i64 %277
%279 = load i32, i32* %278
%280 = icmp slt i32 %279, 0
br i1 %280, label %281, label %284
281: ; preds = %255
%282 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.10, i64 0, i64 0))
%283 = call i32 @exit(i32 1)
unreachable
284: ; preds = %255
br label %285
285: ; preds = %284
%286 = load i32, i32* %8
%287 = add nsw i32 %286, 1
store i32 %287, i32* %8
br label %251
288: ; preds = %251
br label %289
289: ; preds = %288
%290 = load i32, i32* %7
%291 = add nsw i32 %290, 1
store i32 %291, i32* %7
br label %246
292: ; preds = %246
%293 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.11, i64 0, i64 0))
store i32 0, i32* %7
br label %294
294: ; preds = %305, %292
%295 = load i32, i32* %7
%296 = load i32, i32* %3
%297 = icmp slt i32 %295, %296
br i1 %297, label %298, label %308
298: ; preds = %294
%299 = load i32*, i32** %10
%300 = load i32, i32* %7
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i32, i32* %299, i64 %301
%303 = load i32, i32* %302
%304 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i32 %303)
br label %305
305: ; preds = %298
%306 = load i32, i32* %7
%307 = add nsw i32 %306, 1
store i32 %307, i32* %7
br label %294
308: ; preds = %294
%309 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0))
store i32 0, i32* %7
br label %310
310: ; preds = %351, %308
%311 = load i32, i32* %7
%312 = load i32, i32* %2
%313 = icmp slt i32 %311, %312
br i1 %313, label %314, label %354
314: ; preds = %310
store i32 0, i32* %8
br label %315
315: ; preds = %347, %314
%316 = load i32, i32* %8
%317 = load i32, i32* %3
%318 = icmp slt i32 %316, %317
br i1 %318, label %319, label %350
319: ; preds = %315
%320 = load i32**, i32*** %5
%321 = load i32, i32* %7
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i32*, i32** %320, i64 %322
%324 = load i32*, i32** %323
%325 = load i32, i32* %8
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %324, i64 %326
%328 = load i32, i32* %327
%329 = load i32**, i32*** %6
%330 = load i32, i32* %7
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds i32*, i32** %329, i64 %331
%333 = load i32*, i32** %332
%334 = load i32, i32* %8
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds i32, i32* %333, i64 %335
%337 = load i32, i32* %336
%338 = sub nsw i32 %328, %337
%339 = load i32**, i32*** %11
%340 = load i32, i32* %7
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32*, i32** %339, i64 %341
%343 = load i32*, i32** %342
%344 = load i32, i32* %8
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds i32, i32* %343, i64 %345
store i32 %338, i32* %346
br label %347
347: ; preds = %319
%348 = load i32, i32* %8
%349 = add nsw i32 %348, 1
store i32 %349, i32* %8
br label %315
350: ; preds = %315
br label %351
351: ; preds = %350
%352 = load i32, i32* %7
%353 = add nsw i32 %352, 1
store i32 %353, i32* %7
br label %310
354: ; preds = %310
%355 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.14, i64 0, i64 0))
store i32 0, i32* %7
br label %356
356: ; preds = %383, %354
%357 = load i32, i32* %7
%358 = load i32, i32* %2
%359 = icmp slt i32 %357, %358
br i1 %359, label %360, label %386
360: ; preds = %356
%361 = load i32, i32* %7
%362 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.15, i64 0, i64 0), i32 %361)
store i32 0, i32* %8
br label %363
363: ; preds = %378, %360
%364 = load i32, i32* %8
%365 = load i32, i32* %3
%366 = icmp slt i32 %364, %365
br i1 %366, label %367, label %381
367: ; preds = %363
%368 = load i32**, i32*** %11
%369 = load i32, i32* %7
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds i32*, i32** %368, i64 %370
%372 = load i32*, i32** %371
%373 = load i32, i32* %8
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %372, i64 %374
%376 = load i32, i32* %375
%377 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i32 %376)
br label %378
378: ; preds = %367
%379 = load i32, i32* %8
%380 = add nsw i32 %379, 1
store i32 %380, i32* %8
br label %363
381: ; preds = %363
%382 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0))
br label %383
383: ; preds = %381
%384 = load i32, i32* %7
%385 = add nsw i32 %384, 1
store i32 %385, i32* %7
br label %356
386: ; preds = %356
%387 = load i32, i32* %2
%388 = load i32, i32* %3
%389 = load i32*, i32** %10
%390 = load i32**, i32*** %11
%391 = load i32**, i32*** %6
%392 = call i32 @security(i32 %387, i32 %388, i32* %389, i32** %390, i32** %391)
%393 = icmp eq i32 %392, 1
br i1 %393, label %394, label %396
394: ; preds = %386
%395 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i64 0, i64 0))
br label %398
396: ; preds = %386
%397 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.17, i64 0, i64 0))
br label %398
398: ; preds = %396, %394
store i32 0, i32* %7
br label %399
399: ; preds = %430, %398
%400 = load i32, i32* %7
%401 = load i32, i32* %2
%402 = icmp slt i32 %400, %401
br i1 %402, label %403, label %433
403: ; preds = %399
store i32 0, i32* %8
br label %404
404: ; preds = %426, %403
%405 = load i32, i32* %8
%406 = load i32, i32* %3
%407 = icmp slt i32 %405, %406
br i1 %407, label %408, label %429
408: ; preds = %404
%409 = load i32**, i32*** %6
%410 = load i32, i32* %7
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds i32*, i32** %409, i64 %411
%413 = load i32*, i32** %412
%414 = load i32, i32* %8
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i32, i32* %413, i64 %415
%417 = load i32, i32* %416
%418 = load i32**, i32*** %14
%419 = load i32, i32* %7
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds i32*, i32** %418, i64 %420
%422 = load i32*, i32** %421
%423 = load i32, i32* %8
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds i32, i32* %422, i64 %424
store i32 %417, i32* %425
br label %426
426: ; preds = %408
%427 = load i32, i32* %8
%428 = add nsw i32 %427, 1
store i32 %428, i32* %8
br label %404
429: ; preds = %404
br label %430
430: ; preds = %429
%431 = load i32, i32* %7
%432 = add nsw i32 %431, 1
store i32 %432, i32* %7
br label %399
433: ; preds = %399
br label %434
434: ; preds = %433, %442, %591
%435 = load i32, i32* %2
%436 = load i32, i32* %3
%437 = load i32**, i32*** %11
%438 = load i32*, i32** %10
%439 = load i32*, i32** %13
%440 = call i32 @my_req(i32 %435, i32 %436, i32** %437, i32* %438, i32* %439)
store i32 %440, i32* %15
%441 = icmp eq i32 %440, -1
br i1 %441, label %442, label %443
442: ; preds = %434
br label %434
443: ; preds = %434
store i32 0, i32* %7
br label %444
444: ; preds = %498, %443
%445 = load i32, i32* %7
%446 = load i32, i32* %3
%447 = icmp slt i32 %445, %446
br i1 %447, label %448, label %501
448: ; preds = %444
%449 = load i32*, i32** %13
%450 = load i32, i32* %7
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds i32, i32* %449, i64 %451
%453 = load i32, i32* %452
%454 = load i32**, i32*** %6
%455 = load i32, i32* %15
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i32*, i32** %454, i64 %456
%458 = load i32*, i32** %457
%459 = load i32, i32* %7
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds i32, i32* %458, i64 %460
%462 = load i32, i32* %461
%463 = add nsw i32 %453, %462
%464 = load i32**, i32*** %14
%465 = load i32, i32* %15
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds i32*, i32** %464, i64 %466
%468 = load i32*, i32** %467
%469 = load i32, i32* %7
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds i32, i32* %468, i64 %470
store i32 %463, i32* %471
%472 = load i32*, i32** %13
%473 = load i32, i32* %7
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i32, i32* %472, i64 %474
%476 = load i32, i32* %475
%477 = load i32*, i32** %10
%478 = load i32, i32* %7
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds i32, i32* %477, i64 %479
%481 = load i32, i32* %480
%482 = sub nsw i32 %481, %476
store i32 %482, i32* %480
%483 = load i32*, i32** %13
%484 = load i32, i32* %7
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i32, i32* %483, i64 %485
%487 = load i32, i32* %486
%488 = load i32**, i32*** %11
%489 = load i32, i32* %15
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds i32*, i32** %488, i64 %490
%492 = load i32*, i32** %491
%493 = load i32, i32* %7
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds i32, i32* %492, i64 %494
%496 = load i32, i32* %495
%497 = sub nsw i32 %496, %487
store i32 %497, i32* %495
br label %498
498: ; preds = %448
%499 = load i32, i32* %7
%500 = add nsw i32 %499, 1
store i32 %500, i32* %7
br label %444
501: ; preds = %444
%502 = load i32, i32* %2
%503 = load i32, i32* %3
%504 = load i32*, i32** %10
%505 = load i32**, i32*** %11
%506 = load i32**, i32*** %14
%507 = call i32 @security(i32 %502, i32 %503, i32* %504, i32** %505, i32** %506)
%508 = icmp eq i32 %507, 1
br i1 %508, label %509, label %537
509: ; preds = %501
%510 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.18, i64 0, i64 0))
store i32 0, i32* %7
br label %511
511: ; preds = %533, %509
%512 = load i32, i32* %7
%513 = load i32, i32* %3
%514 = icmp slt i32 %512, %513
br i1 %514, label %515, label %536
515: ; preds = %511
%516 = load i32**, i32*** %14
%517 = load i32, i32* %15
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds i32*, i32** %516, i64 %518
%520 = load i32*, i32** %519
%521 = load i32, i32* %7
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i32, i32* %520, i64 %522
%524 = load i32, i32* %523
%525 = load i32**, i32*** %6
%526 = load i32, i32* %15
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds i32*, i32** %525, i64 %527
%529 = load i32*, i32** %528
%530 = load i32, i32* %7
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds i32, i32* %529, i64 %531
store i32 %524, i32* %532
br label %533
533: ; preds = %515
%534 = load i32, i32* %7
%535 = add nsw i32 %534, 1
store i32 %535, i32* %7
br label %511
536: ; preds = %511
br label %591
537: ; preds = %501
%538 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.19, i64 0, i64 0))
store i32 0, i32* %7
br label %539
539: ; preds = %587, %537
%540 = load i32, i32* %7
%541 = load i32, i32* %3
%542 = icmp slt i32 %540, %541
br i1 %542, label %543, label %590
543: ; preds = %539
%544 = load i32**, i32*** %6
%545 = load i32, i32* %15
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds i32*, i32** %544, i64 %546
%548 = load i32*, i32** %547
%549 = load i32, i32* %7
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds i32, i32* %548, i64 %550
%552 = load i32, i32* %551
%553 = load i32**, i32*** %14
%554 = load i32, i32* %15
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i32*, i32** %553, i64 %555
%557 = load i32*, i32** %556
%558 = load i32, i32* %7
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds i32, i32* %557, i64 %559
store i32 %552, i32* %560
%561 = load i32*, i32** %13
%562 = load i32, i32* %7
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds i32, i32* %561, i64 %563
%565 = load i32, i32* %564
%566 = load i32*, i32** %10
%567 = load i32, i32* %7
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds i32, i32* %566, i64 %568
%570 = load i32, i32* %569
%571 = add nsw i32 %570, %565
store i32 %571, i32* %569
%572 = load i32*, i32** %13
%573 = load i32, i32* %7
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds i32, i32* %572, i64 %574
%576 = load i32, i32* %575
%577 = load i32**, i32*** %11
%578 = load i32, i32* %15
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds i32*, i32** %577, i64 %579
%581 = load i32*, i32** %580
%582 = load i32, i32* %7
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds i32, i32* %581, i64 %583
%585 = load i32, i32* %584
%586 = add nsw i32 %585, %576
store i32 %586, i32* %584
br label %587
587: ; preds = %543
%588 = load i32, i32* %7
%589 = add nsw i32 %588, 1
store i32 %589, i32* %7
br label %539
590: ; preds = %539
br label %591
591: ; preds = %590, %536
br label %434
}

LLVM IR (-O2):
@.str = [22 x i8] c"\E8\BE\93\E5\85\A5\E8\BF\9B\E7\A8\8B\E4\B8\AA\E6\95\B0\EF\BC\9A\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [22 x i8] c"\E8\BE\93\E5\85\A5\E8\B5\84\E6\BA\90\E4\B8\AA\E6\95\B0\EF\BC\9A\00"
@.str.3 = [17 x i8] c"malloc all error\00"
@.str.4 = [23 x i8] c"malloc available error\00"
@.str.5 = [17 x i8] c"malloc req error\00"
@.str.8 = [24 x i8] c"\E8\BE\93\E5\85\A5\E6\9C\89\E8\AF\AF\EF\BC\81%d > %d\0A\00"
@.str.12 = [4 x i8] c"%d \00"
@.str.15 = [6 x i8] c"p%d: \00"
@str = [37 x i8] c"\E8\BE\93\E5\85\A5\E6\AF\8F\E7\B1\BB\E8\B5\84\E6\BA\90\E7\9A\84\E6\9C\80\E5\A4\A7\E6\95\B0\E9\87\8F\EF\BC\9A\00"
@str.20 = [37 x i8] c"\E8\BE\93\E5\85\A5\E8\BF\9B\E7\A8\8B\E7\9A\84\E6\9C\80\E5\A4\A7\E9\9C\80\E6\B1\82\E7\9F\A9\E9\98\B5\EF\BC\9A\00"
@str.21 = [40 x i8] c"\E8\BE\93\E5\85\A5\E8\BF\9B\E7\A8\8B\E7\9A\84\E5\B7\B2\E5\88\86\E9\85\8D\E8\B5\84\E6\BA\90\E7\9F\A9\E9\98\B5\EF\BC\9A\00"
@str.22 = [32 x i8] c"\E5\BD\93\E5\89\8D\E6\97\B6\E5\88\BB\E7\9A\84\E5\8F\AF\E5\88\A9\E7\94\A8\E8\B5\84\E6\BA\90:\00"
@str.23 = [42 x i8] c"\E5\BD\93\E5\89\8D\E6\97\B6\E5\88\BBn\E4\B8\AA\E8\BF\9B\E7\A8\8B\E7\9A\84\E8\BF\98\E9\9C\80\E8\A6\81\E8\B5\84\E6\BA\90:\00"
@str.24 = [23 x i8] c"\E5\88\9D\E5\A7\8B\E7\8A\B6\E6\80\81\E4\B8\8D\E5\AE\89\E5\85\A8!\00"
@str.25 = [42 x i8] c"\E6\AD\A4\E6\AC\A1\E8\B5\84\E6\BA\90\E5\88\86\E9\85\8D\E4\B8\8D\E5\AE\89\E5\85\A8!\E5\8F\96\E6\B6\88\E5\88\86\E9\85\8D!\00"
@str.26 = [26 x i8] c"\E6\AD\A4\E6\AC\A1\E8\B5\84\E6\BA\90\E5\88\86\E9\85\8D\E5\AE\89\E5\85\A8!\00"
@str.27 = [20 x i8] c"\E5\88\9D\E5\A7\8B\E7\8A\B6\E6\80\81\E5\AE\89\E5\85\A8!\00"
@str.28 = [19 x i8] c"\E5\8F\AF\E7\94\A8\E8\B5\84\E6\BA\90\E4\B8\8D\E8\B6\B3\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = bitcast i32* %1 to i8*
store i32 0, i32* %1
%4 = bitcast i32* %2 to i8*
store i32 0, i32* %2
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
%6 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%7 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0))
%8 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%9 = load i32, i32* %2
%10 = shl i32 %9, 2
%11 = call i64 @malloc(i32 %10)
%12 = inttoptr i64 %11 to i32*
%13 = icmp eq i64 %11, 0
br i1 %13, label %14, label %17
14: ; preds = %0
%15 = call i32 @perror(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0))
%16 = call i32 @exit(i32 1)
unreachable
17: ; preds = %0
%18 = load i32, i32* %2
%19 = shl i32 %18, 2
%20 = call i64 @malloc(i32 %19)
%21 = inttoptr i64 %20 to i32*
%22 = icmp eq i64 %20, 0
br i1 %22, label %23, label %26
23: ; preds = %17
%24 = call i32 @perror(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0))
%25 = call i32 @exit(i32 1)
unreachable
26: ; preds = %17
%27 = load i32, i32* %2
%28 = shl i32 %27, 2
%29 = call i64 @malloc(i32 %28)
%30 = inttoptr i64 %29 to i32*
%31 = icmp eq i64 %29, 0
br i1 %31, label %32, label %35
32: ; preds = %26
%33 = call i32 @perror(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0))
%34 = call i32 @exit(i32 1)
unreachable
35: ; preds = %26
%36 = load i32, i32* %1
%37 = load i32, i32* %2
%38 = call i32** @my_malloc(i32 %36, i32 %37)
%39 = load i32, i32* %1
%40 = load i32, i32* %2
%41 = call i32** @my_malloc(i32 %39, i32 %40)
%42 = load i32, i32* %1
%43 = load i32, i32* %2
%44 = call i32** @my_malloc(i32 %42, i32 %43)
%45 = load i32, i32* %1
%46 = load i32, i32* %2
%47 = call i32** @my_malloc(i32 %45, i32 %46)
%48 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str, i64 0, i64 0))
%49 = load i32, i32* %2
%50 = icmp sgt i32 %49, 0
br i1 %50, label %51, label %59
51: ; preds = %35, %51
%52 = phi i64 [ %55, %51 ], [ 0, %35 ]
%53 = getelementptr inbounds i32, i32* %12, i64 %52
%54 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %53)
%55 = add nuw nsw i64 %52, 1
%56 = load i32, i32* %2
%57 = sext i32 %56 to i64
%58 = icmp slt i64 %55, %57
br i1 %58, label %51, label %59
59: ; preds = %51, %35
%60 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str.20, i64 0, i64 0))
%61 = load i32, i32* %1
%62 = icmp sgt i32 %61, 0
br i1 %62, label %63, label %105
63: ; preds = %59
%64 = load i32, i32* %2
br label %65
65: ; preds = %63, %99
%66 = phi i32 [ %64, %63 ], [ %100, %99 ]
%67 = phi i64 [ 0, %63 ], [ %101, %99 ]
%68 = icmp sgt i32 %66, 0
br i1 %68, label %69, label %99
69: ; preds = %65
%70 = getelementptr inbounds i32*, i32** %38, i64 %67
br label %77
71: ; preds = %77
%72 = icmp sgt i32 %83, 0
br i1 %72, label %73, label %99
73: ; preds = %71
%74 = getelementptr inbounds i32*, i32** %38, i64 %67
%75 = load i32*, i32** %74
%76 = zext i32 %83 to i64
br label %88
77: ; preds = %69, %77
%78 = phi i64 [ 0, %69 ], [ %82, %77 ]
%79 = load i32*, i32** %70
%80 = getelementptr inbounds i32, i32* %79, i64 %78
%81 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %80)
%82 = add nuw nsw i64 %78, 1
%83 = load i32, i32* %2
%84 = sext i32 %83 to i64
%85 = icmp slt i64 %82, %84
br i1 %85, label %77, label %71
86: ; preds = %88
%87 = icmp eq i64 %95, %76
br i1 %87, label %99, label %88
88: ; preds = %73, %86
%89 = phi i64 [ 0, %73 ], [ %95, %86 ]
%90 = getelementptr inbounds i32, i32* %75, i64 %89
%91 = load i32, i32* %90
%92 = getelementptr inbounds i32, i32* %12, i64 %89
%93 = load i32, i32* %92
%94 = icmp sgt i32 %91, %93
%95 = add nuw nsw i64 %89, 1
br i1 %94, label %96, label %86
96: ; preds = %88
%97 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.8, i64 0, i64 0), i32 %91, i32 %93)
%98 = call i32 @exit(i32 1)
unreachable
99: ; preds = %86, %65, %71
%100 = phi i32 [ %83, %71 ], [ %66, %65 ], [ %83, %86 ]
%101 = add nuw nsw i64 %67, 1
%102 = load i32, i32* %1
%103 = sext i32 %102 to i64
%104 = icmp slt i64 %101, %103
br i1 %104, label %65, label %105
105: ; preds = %99, %59
%106 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str.21, i64 0, i64 0))
%107 = load i32, i32* %1
%108 = icmp sgt i32 %107, 0
%109 = load i32, i32* %2
br i1 %108, label %110, label %116
110: ; preds = %105, %150
%111 = phi i32 [ %151, %150 ], [ %109, %105 ]
%112 = phi i64 [ %152, %150 ], [ 0, %105 ]
%113 = icmp sgt i32 %111, 0
br i1 %113, label %114, label %150
114: ; preds = %110
%115 = getelementptr inbounds i32*, i32** %41, i64 %112
br label %128
116: ; preds = %150, %105
%117 = phi i32 [ %107, %105 ], [ %153, %150 ]
%118 = phi i32 [ %109, %105 ], [ %151, %150 ]
%119 = icmp sgt i32 %118, 0
br i1 %119, label %162, label %158
120: ; preds = %128
%121 = icmp sgt i32 %134, 0
br i1 %121, label %122, label %150
122: ; preds = %120
%123 = getelementptr inbounds i32*, i32** %41, i64 %112
%124 = load i32*, i32** %123
%125 = getelementptr inbounds i32*, i32** %38, i64 %112
%126 = load i32*, i32** %125
%127 = zext i32 %134 to i64
br label %139
128: ; preds = %114, %128
%129 = phi i64 [ 0, %114 ], [ %133, %128 ]
%130 = load i32*, i32** %115
%131 = getelementptr inbounds i32, i32* %130, i64 %129
%132 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %131)
%133 = add nuw nsw i64 %129, 1
%134 = load i32, i32* %2
%135 = sext i32 %134 to i64
%136 = icmp slt i64 %133, %135
br i1 %136, label %128, label %120
137: ; preds = %139
%138 = icmp eq i64 %146, %127
br i1 %138, label %150, label %139
139: ; preds = %122, %137
%140 = phi i64 [ 0, %122 ], [ %146, %137 ]
%141 = getelementptr inbounds i32, i32* %124, i64 %140
%142 = load i32, i32* %141
%143 = getelementptr inbounds i32, i32* %126, i64 %140
%144 = load i32, i32* %143
%145 = icmp sgt i32 %142, %144
%146 = add nuw nsw i64 %140, 1
br i1 %145, label %147, label %137
147: ; preds = %139
%148 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.8, i64 0, i64 0), i32 %142, i32 %144)
%149 = call i32 @exit(i32 1)
unreachable
150: ; preds = %137, %110, %120
%151 = phi i32 [ %134, %120 ], [ %111, %110 ], [ %134, %137 ]
%152 = add nuw nsw i64 %112, 1
%153 = load i32, i32* %1
%154 = sext i32 %153 to i64
%155 = icmp slt i64 %152, %154
br i1 %155, label %110, label %116
156: ; preds = %162
%157 = load i32, i32* %1
br label %158
158: ; preds = %156, %116
%159 = phi i32 [ %168, %156 ], [ %118, %116 ]
%160 = phi i32 [ %157, %156 ], [ %117, %116 ]
%161 = icmp sgt i32 %160, 0
br i1 %161, label %171, label %203
162: ; preds = %116, %162
%163 = phi i64 [ %167, %162 ], [ 0, %116 ]
%164 = getelementptr inbounds i32, i32* %12, i64 %163
%165 = load i32, i32* %164
%166 = getelementptr inbounds i32, i32* %21, i64 %163
store i32 %165, i32* %166
%167 = add nuw nsw i64 %163, 1
%168 = load i32, i32* %2
%169 = sext i32 %168 to i64
%170 = icmp slt i64 %167, %169
br i1 %170, label %162, label %156
171: ; preds = %158, %197
%172 = phi i32 [ %198, %197 ], [ %160, %158 ]
%173 = phi i32 [ %199, %197 ], [ %159, %158 ]
%174 = phi i64 [ %200, %197 ], [ 0, %158 ]
%175 = icmp sgt i32 %173, 0
br i1 %175, label %176, label %197
176: ; preds = %171
%177 = getelementptr inbounds i32*, i32** %41, i64 %174
%178 = load i32*, i32** %177
br label %183
179: ; preds = %183
%180 = load i32, i32* %2
%181 = sext i32 %180 to i64
%182 = icmp slt i64 %191, %181
br i1 %182, label %183, label %195
183: ; preds = %176, %179
%184 = phi i64 [ 0, %176 ], [ %191, %179 ]
%185 = getelementptr inbounds i32, i32* %21, i64 %184
%186 = load i32, i32* %185
%187 = getelementptr inbounds i32, i32* %178, i64 %184
%188 = load i32, i32* %187
%189 = sub nsw i32 %186, %188
store i32 %189, i32* %185
%190 = icmp slt i32 %189, 0
%191 = add nuw nsw i64 %184, 1
br i1 %190, label %192, label %179
192: ; preds = %183
%193 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.28, i64 0, i64 0))
%194 = call i32 @exit(i32 1)
unreachable
195: ; preds = %179
%196 = load i32, i32* %1
br label %197
197: ; preds = %195, %171
%198 = phi i32 [ %196, %195 ], [ %172, %171 ]
%199 = phi i32 [ %180, %195 ], [ %173, %171 ]
%200 = add nuw nsw i64 %174, 1
%201 = sext i32 %198 to i64
%202 = icmp slt i64 %200, %201
br i1 %202, label %171, label %203
203: ; preds = %197, %158
%204 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.22, i64 0, i64 0))
%205 = load i32, i32* %2
%206 = icmp sgt i32 %205, 0
br i1 %206, label %207, label %216
207: ; preds = %203, %207
%208 = phi i64 [ %212, %207 ], [ 0, %203 ]
%209 = getelementptr inbounds i32, i32* %21, i64 %208
%210 = load i32, i32* %209
%211 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i32 %210)
%212 = add nuw nsw i64 %208, 1
%213 = load i32, i32* %2
%214 = sext i32 %213 to i64
%215 = icmp slt i64 %212, %214
br i1 %215, label %207, label %216
216: ; preds = %207, %203
%217 = call i32 @putchar(i32 10)
%218 = load i32, i32* %1
%219 = icmp sgt i32 %218, 0
br i1 %219, label %220, label %254
220: ; preds = %216
%221 = load i32, i32* %2
br label %222
222: ; preds = %220, %248
%223 = phi i32 [ %218, %220 ], [ %249, %248 ]
%224 = phi i32 [ %221, %220 ], [ %250, %248 ]
%225 = phi i64 [ 0, %220 ], [ %251, %248 ]
%226 = icmp sgt i32 %224, 0
br i1 %226, label %227, label %248
227: ; preds = %222
%228 = getelementptr inbounds i32*, i32** %38, i64 %225
%229 = load i32*, i32** %228
%230 = getelementptr inbounds i32*, i32** %41, i64 %225
%231 = load i32*, i32** %230
%232 = getelementptr inbounds i32*, i32** %44, i64 %225
%233 = load i32*, i32** %232
br label %234
234: ; preds = %227, %234
%235 = phi i64 [ 0, %227 ], [ %242, %234 ]
%236 = getelementptr inbounds i32, i32* %229, i64 %235
%237 = load i32, i32* %236
%238 = getelementptr inbounds i32, i32* %231, i64 %235
%239 = load i32, i32* %238
%240 = sub nsw i32 %237, %239
%241 = getelementptr inbounds i32, i32* %233, i64 %235
store i32 %240, i32* %241
%242 = add nuw nsw i64 %235, 1
%243 = load i32, i32* %2
%244 = sext i32 %243 to i64
%245 = icmp slt i64 %242, %244
br i1 %245, label %234, label %246
246: ; preds = %234
%247 = load i32, i32* %1
br label %248
248: ; preds = %246, %222
%249 = phi i32 [ %247, %246 ], [ %223, %222 ]
%250 = phi i32 [ %243, %246 ], [ %224, %222 ]
%251 = add nuw nsw i64 %225, 1
%252 = sext i32 %249 to i64
%253 = icmp slt i64 %251, %252
br i1 %253, label %222, label %254
254: ; preds = %248, %216
%255 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.23, i64 0, i64 0))
%256 = load i32, i32* %1
%257 = icmp sgt i32 %256, 0
br i1 %257, label %258, label %282
258: ; preds = %254, %276
%259 = phi i64 [ %278, %276 ], [ 0, %254 ]
%260 = trunc i64 %259 to i32
%261 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.15, i64 0, i64 0), i32 %260)
%262 = load i32, i32* %2
%263 = icmp sgt i32 %262, 0
br i1 %263, label %264, label %276
264: ; preds = %258
%265 = getelementptr inbounds i32*, i32** %44, i64 %259
br label %266
266: ; preds = %264, %266
%267 = phi i64 [ 0, %264 ], [ %272, %266 ]
%268 = load i32*, i32** %265
%269 = getelementptr inbounds i32, i32* %268, i64 %267
%270 = load i32, i32* %269
%271 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i32 %270)
%272 = add nuw nsw i64 %267, 1
%273 = load i32, i32* %2
%274 = sext i32 %273 to i64
%275 = icmp slt i64 %272, %274
br i1 %275, label %266, label %276
276: ; preds = %266, %258
%277 = call i32 @putchar(i32 10)
%278 = add nuw nsw i64 %259, 1
%279 = load i32, i32* %1
%280 = sext i32 %279 to i64
%281 = icmp slt i64 %278, %280
br i1 %281, label %258, label %282
282: ; preds = %276, %254
%283 = phi i32 [ %256, %254 ], [ %279, %276 ]
%284 = load i32, i32* %2
%285 = call i32 @security(i32 %283, i32 %284, i32* %21, i32** %44, i32** %41)
%286 = icmp eq i32 %285, 1
%287 = select i1 %286, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @str.27, i64 0, i64 0), i8* getelementptr inbounds ([23 x i8], [23 x i8]* @str.24, i64 0, i64 0)
%288 = call i32 @puts(i8* dereferenceable(1) %287)
%289 = load i32, i32* %1
%290 = icmp sgt i32 %289, 0
br i1 %290, label %291, label %320
291: ; preds = %282
%292 = load i32, i32* %2
br label %293
293: ; preds = %291, %314
%294 = phi i32 [ %289, %291 ], [ %315, %314 ]
%295 = phi i32 [ %292, %291 ], [ %316, %314 ]
%296 = phi i64 [ 0, %291 ], [ %317, %314 ]
%297 = icmp sgt i32 %295, 0
br i1 %297, label %298, label %314
298: ; preds = %293
%299 = getelementptr inbounds i32*, i32** %41, i64 %296
%300 = load i32*, i32** %299
%301 = getelementptr inbounds i32*, i32** %47, i64 %296
%302 = load i32*, i32** %301
br label %303
303: ; preds = %298, %303
%304 = phi i64 [ 0, %298 ], [ %308, %303 ]
%305 = getelementptr inbounds i32, i32* %300, i64 %304
%306 = load i32, i32* %305
%307 = getelementptr inbounds i32, i32* %302, i64 %304
store i32 %306, i32* %307
%308 = add nuw nsw i64 %304, 1
%309 = load i32, i32* %2
%310 = sext i32 %309 to i64
%311 = icmp slt i64 %308, %310
br i1 %311, label %303, label %312
312: ; preds = %303
%313 = load i32, i32* %1
br label %314
314: ; preds = %312, %293
%315 = phi i32 [ %313, %312 ], [ %294, %293 ]
%316 = phi i32 [ %309, %312 ], [ %295, %293 ]
%317 = add nuw nsw i64 %296, 1
%318 = sext i32 %315 to i64
%319 = icmp slt i64 %317, %318
br i1 %319, label %293, label %320
320: ; preds = %314, %282
%321 = phi i32 [ %289, %282 ], [ %315, %314 ]
br label %322
322: ; preds = %320, %412
%323 = phi i32 [ %413, %412 ], [ %321, %320 ]
%324 = load i32, i32* %2
%325 = call i32 @my_req(i32 %323, i32 %324, i32** %44, i32* %21, i32* %30)
%326 = icmp eq i32 %325, -1
br i1 %326, label %412, label %327
327: ; preds = %322
%328 = load i32, i32* %2
%329 = icmp sgt i32 %328, 0
br i1 %329, label %330, label %358
330: ; preds = %327
%331 = sext i32 %325 to i64
%332 = getelementptr inbounds i32*, i32** %41, i64 %331
%333 = load i32*, i32** %332
%334 = getelementptr inbounds i32*, i32** %47, i64 %331
%335 = load i32*, i32** %334
%336 = getelementptr inbounds i32*, i32** %44, i64 %331
%337 = load i32*, i32** %336
br label %338
338: ; preds = %330, %338
%339 = phi i64 [ 0, %330 ], [ %354, %338 ]
%340 = getelementptr inbounds i32, i32* %30, i64 %339
%341 = load i32, i32* %340
%342 = getelementptr inbounds i32, i32* %333, i64 %339
%343 = load i32, i32* %342
%344 = add nsw i32 %343, %341
%345 = getelementptr inbounds i32, i32* %335, i64 %339
store i32 %344, i32* %345
%346 = load i32, i32* %340
%347 = getelementptr inbounds i32, i32* %21, i64 %339
%348 = load i32, i32* %347
%349 = sub nsw i32 %348, %346
store i32 %349, i32* %347
%350 = load i32, i32* %340
%351 = getelementptr inbounds i32, i32* %337, i64 %339
%352 = load i32, i32* %351
%353 = sub nsw i32 %352, %350
store i32 %353, i32* %351
%354 = add nuw nsw i64 %339, 1
%355 = load i32, i32* %2
%356 = sext i32 %355 to i64
%357 = icmp slt i64 %354, %356
br i1 %357, label %338, label %358
358: ; preds = %338, %327
%359 = phi i32 [ %328, %327 ], [ %355, %338 ]
%360 = load i32, i32* %1
%361 = call i32 @security(i32 %360, i32 %359, i32* %21, i32** %44, i32** %47)
%362 = icmp eq i32 %361, 1
br i1 %362, label %363, label %382
363: ; preds = %358
%364 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.26, i64 0, i64 0))
%365 = load i32, i32* %2
%366 = icmp sgt i32 %365, 0
br i1 %366, label %367, label %412
367: ; preds = %363
%368 = sext i32 %325 to i64
%369 = getelementptr inbounds i32*, i32** %47, i64 %368
%370 = load i32*, i32** %369
%371 = getelementptr inbounds i32*, i32** %41, i64 %368
%372 = load i32*, i32** %371
br label %373
373: ; preds = %367, %373
%374 = phi i64 [ 0, %367 ], [ %378, %373 ]
%375 = getelementptr inbounds i32, i32* %370, i64 %374
%376 = load i32, i32* %375
%377 = getelementptr inbounds i32, i32* %372, i64 %374
store i32 %376, i32* %377
%378 = add nuw nsw i64 %374, 1
%379 = load i32, i32* %2
%380 = sext i32 %379 to i64
%381 = icmp slt i64 %378, %380
br i1 %381, label %373, label %412
382: ; preds = %358
%383 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.25, i64 0, i64 0))
%384 = load i32, i32* %2
%385 = icmp sgt i32 %384, 0
br i1 %385, label %386, label %412
386: ; preds = %382
%387 = sext i32 %325 to i64
%388 = getelementptr inbounds i32*, i32** %41, i64 %387
%389 = load i32*, i32** %388
%390 = getelementptr inbounds i32*, i32** %47, i64 %387
%391 = load i32*, i32** %390
%392 = getelementptr inbounds i32*, i32** %44, i64 %387
%393 = load i32*, i32** %392
br label %394
394: ; preds = %386, %394
%395 = phi i64 [ 0, %386 ], [ %408, %394 ]
%396 = getelementptr inbounds i32, i32* %389, i64 %395
%397 = load i32, i32* %396
%398 = getelementptr inbounds i32, i32* %391, i64 %395
store i32 %397, i32* %398
%399 = getelementptr inbounds i32, i32* %30, i64 %395
%400 = load i32, i32* %399
%401 = getelementptr inbounds i32, i32* %21, i64 %395
%402 = load i32, i32* %401
%403 = add nsw i32 %402, %400
store i32 %403, i32* %401
%404 = load i32, i32* %399
%405 = getelementptr inbounds i32, i32* %393, i64 %395
%406 = load i32, i32* %405
%407 = add nsw i32 %406, %404
store i32 %407, i32* %405
%408 = add nuw nsw i64 %395, 1
%409 = load i32, i32* %2
%410 = sext i32 %409 to i64
%411 = icmp slt i64 %408, %410
br i1 %411, label %394, label %412
412: ; preds = %394, %373, %363, %382, %322
%413 = load i32, i32* %1
br label %322
}