#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 EXIT_FAILURE;
int *calloc(int, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int processo(void) {
  int r, i, j, xr, yr, Au, *a, *x0, *xf, *y0, *yf;
  printf("Digite o numero de redes: \n");
  scanf("%d", &r);
  if (r < 1 || r > 100) {
    printf("Error, try again.\n");
    return EXIT_FAILURE;
  }
  x0 = calloc(r, sizeof(int));
  xf = calloc(r, sizeof(int));
  y0 = calloc(r, sizeof(int));
  yf = calloc(r, sizeof(int));
  a = calloc(r, sizeof(int));
  i = 0;
  while (i < r) {
    printf("Digite o valo de x0 da rede %d\n", i + 1);
    scanf("%d", &x0[i]);
    printf("Digite o valo de xf da rede %d\n", i + 1);
    scanf("%d", &xf[i]);
    printf("Digite o valo de y0 da rede %d\n", i + 1);
    scanf("%d", &y0[i]);
    printf("Digite o valo de yf da rede %d\n", i + 1);
    scanf("%i", &yf[i]);
    if ((x0[i] < 1 || x0[i] > 100) || (xf[i] < 1 || xf[i] > 100) ||
        (y0[i] < 1 || y0[i] > 100) || (yf[i] < 1 || yf[i] > 100)) {
      printf("Error, try again.\n");
      return EXIT_FAILURE;
    }
    a[i] = (xf[i] - x0[i]) * (yf[i] - y0[i]);
    i++;
  }
  if (r == 1) {
    a[0] = (xf[0] - x0[0]) * (yf[0] - y0[0]);
    return a[0];
  }
  i = 0;
  Au = 0;
  while (i < r) {
    Au = Au + a[i];
    i++;
  }
  i = 0;
  for (i = 0; i < r - 1; i++) {
    for (j = i + 1; j < r; j++) {
      if ((x0[i] <= x0[j] && x0[j] <= xf[i]) &&
          (x0[i] <= xf[j] && xf[j] <= xf[i])) {
        xr = (xf[j] - x0[j]);
        if ((y0[i] <= y0[j] && y0[j] <= yf[i]) &&
            (y0[i] <= yf[j] && yf[j] <= yf[i])) {
          yr = yf[j] - y0[i];
          Au = Au - (xr * yr);
        }
        if ((y0[j] < y0[i]) && (y0[i] < yf[j] && yf[j] <= yf[i])) {
          yr = yf[j] - y0[i];
          Au = Au - (xr * yr);
        }
        if ((y0[i] <= y0[j] && y0[j] < yf[i]) && (yf[j] > yf[i])) {
          yr = (yf[i] - y0[j]);
          Au = Au - (xr * yr);
        }
        if ((y0[i] <= y0[j] && y0[j] <= yf[i]) &&
            (y0[i] <= yf[j] && yf[j] <= yf[i])) {
          yr = (yf[j] - y0[j]);
          Au = Au - (xr * yr);
        }
        if ((y0[j] < y0[i]) && (yf[j] > yf[i])) {
          yr = yf[i] - y0[i];
          Au = Au - (xr * yr);
        }
      }
      if ((y0[i] <= y0[j] && y0[j] <= yf[i] && y0[i] <= yf[j] &&
           yf[j] <= yf[i])) {
        if (x0[i] <= x0[j] && x0[j] <= xf[i] && x0[i] <= xf[j] &&
            xf[j] <= xf[i])
          Au = Au;
        if (x0[j] <= x0[i] && x0[i] <= xf[j] && xf[j] <= xf[i])
          Au = Au - (yf[j] - y0[j]) * (x0[i] - x0[j]);
        if (x0[i] <= x0[j] && x0[j] <= xf[i] && xf[j] >= xf[i])
          Au = Au - (yf[j] - y0[j]) * (xf[j] - xf[i]);
      }
      if (x0[i] <= x0[j] && x0[j] < xf[i] && xf[j] > xf[i]) {
        xr = (xf[i] - x0[j]);
        if (y0[i] <= y0[j] && y0[j] < yf[i] && yf[j] > yf[i]) {
          yr = (yf[i] - y0[j]);
          Au = Au - (xr * yr);
        }
        if (y0[i] > y0[j] && y0[i] < yf[j] && yf[j] <= yf[i]) {
          yr = (yf[j] - y0[i]);
          Au = Au - (xr * yr);
        }
        if (y0[i] > y0[j] && yf[j] > yf[i]) {
          yr = (yf[i] - y0[i]);
          Au = Au - (xr * yr);
        }
      }
      if (x0[i] < xf[j] && xf[j] <= xf[i] && x0[i] > x0[j]) {
        xr = (xf[j] - x0[i]);
        if (y0[i] <= y0[j] && y0[j] < yf[i] && yf[j] > yf[i]) {
          yr = (yf[i] - y0[j]);
          Au = Au - (xr * yr);
        }
        if (y0[i] < yf[j] && yf[j] <= yf[i] && y0[i] > y0[j]) {
          yr = (yf[j] - y0[i]);
          Au = Au - (xr * yr);
        }
        if (y0[i] > y0[j] && yf[j] > yf[i]) {
          yr = (yf[i] - y0[i]);
          Au = Au - (xr * yr);
        }
      }
    }
  }
  return Au;
}


x86 assembly (clang, -O0):
<processo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
lea    0xec1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xecf(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1050 <scanf@plt>
cmpl   $0x1,-0x8(%rbp)
jl     116a <processo+0x3a>
cmpl   $0x64,-0x8(%rbp)
jle    1189 <processo+0x59>
lea    0xeae(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2e61(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1d21 <processo+0xbf1>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13a4 <processo+0x274>
mov    -0xc(%rbp),%esi
add    $0x1,%esi
lea    0xe34(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe01(%rip),%rdi
call   1050 <scanf@plt>
mov    -0xc(%rbp),%esi
add    $0x1,%esi
lea    0xe25(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xdd2(%rip),%rdi
call   1050 <scanf@plt>
mov    -0xc(%rbp),%esi
add    $0x1,%esi
lea    0xe16(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x40(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xda3(%rip),%rdi
call   1050 <scanf@plt>
mov    -0xc(%rbp),%esi
add    $0x1,%esi
lea    0xe07(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x48(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe0a(%rip),%rdi
call   1050 <scanf@plt>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jl     133d <processo+0x20d>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x64,(%rax,%rcx,4)
jg     133d <processo+0x20d>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jl     133d <processo+0x20d>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x64,(%rax,%rcx,4)
jg     133d <processo+0x20d>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jl     133d <processo+0x20d>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x64,(%rax,%rcx,4)
jg     133d <processo+0x20d>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jl     133d <processo+0x20d>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x64,(%rax,%rcx,4)
jle    135c <processo+0x22c>
lea    0xcdb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2c8e(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1d21 <processo+0xbf1>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rsi
sub    (%rcx,%rsi,4),%eax
imul   %eax,%edx
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11e5 <processo+0xb5>
cmpl   $0x1,-0x8(%rbp)
jne    13dd <processo+0x2ad>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
sub    (%rax),%ecx
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    -0x40(%rbp),%rdx
sub    (%rdx),%eax
imul   %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1d21 <processo+0xbf1>
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1416 <processo+0x2e6>
mov    -0x1c(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0xc(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13eb <processo+0x2bb>
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1d1b <processo+0xbeb>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1d08 <processo+0xbd8>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1760 <processo+0x630>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1760 <processo+0x630>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1760 <processo+0x630>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1760 <processo+0x630>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x10(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x14(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     156b <processo+0x43b>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     156b <processo+0x43b>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     156b <processo+0x43b>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     156b <processo+0x43b>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    15e7 <processo+0x4b7>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    15e7 <processo+0x4b7>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     15e7 <processo+0x4b7>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1663 <processo+0x533>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1663 <processo+0x533>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1663 <processo+0x533>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     16fb <processo+0x5cb>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     16fb <processo+0x5cb>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     16fb <processo+0x5cb>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     16fb <processo+0x5cb>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    175b <processo+0x62b>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    175b <processo+0x62b>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    1760 <processo+0x630>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1961 <processo+0x831>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1961 <processo+0x831>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1961 <processo+0x831>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1961 <processo+0x831>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1846 <processo+0x716>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1846 <processo+0x716>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1846 <processo+0x716>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1846 <processo+0x716>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     18d1 <processo+0x7a1>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     18d1 <processo+0x7a1>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     18d1 <processo+0x7a1>
mov    -0x1c(%rbp),%eax
mov    -0x48(%rbp),%rcx
movslq -0x10(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x40(%rbp),%rdx
movslq -0x10(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
mov    -0x30(%rbp),%rdx
movslq -0xc(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
mov    -0x30(%rbp),%rsi
movslq -0x10(%rbp),%rdi
sub    (%rsi,%rdi,4),%edx
imul   %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     195c <processo+0x82c>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     195c <processo+0x82c>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     195c <processo+0x82c>
mov    -0x1c(%rbp),%eax
mov    -0x48(%rbp),%rcx
movslq -0x10(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x40(%rbp),%rdx
movslq -0x10(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
mov    -0x38(%rbp),%rdx
movslq -0x10(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
mov    -0x38(%rbp),%rsi
movslq -0xc(%rbp),%rdi
sub    (%rsi,%rdi,4),%edx
imul   %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    1961 <processo+0x831>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1b2b <processo+0x9fb>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1b2b <processo+0x9fb>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1b2b <processo+0x9fb>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x10(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x14(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1a4a <processo+0x91a>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1a4a <processo+0x91a>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1a4a <processo+0x91a>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1ac6 <processo+0x996>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1ac6 <processo+0x996>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1ac6 <processo+0x996>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1b26 <processo+0x9f6>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1b26 <processo+0x9f6>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    1b2b <processo+0x9fb>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1cf5 <processo+0xbc5>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1cf5 <processo+0xbc5>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1cf5 <processo+0xbc5>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x14(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1c14 <processo+0xae4>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1c14 <processo+0xae4>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1c14 <processo+0xae4>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1c90 <processo+0xb60>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1c90 <processo+0xb60>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1c90 <processo+0xb60>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1cf0 <processo+0xbc0>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1cf0 <processo+0xbc0>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    1cf5 <processo+0xbc5>
jmp    1cfa <processo+0xbca>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    143e <processo+0x30e>
jmp    1d0d <processo+0xbdd>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1424 <processo+0x2f4>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<processo>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
lea    0xf31(%rip),%rdi
call   1030 <puts@plt>
lea    0xe9f(%rip),%rdi
lea    0x1c(%rsp),%rsi
call   1060 <scanf@plt>
mov    0x1c(%rsp),%ebp
lea    -0x65(%rbp),%eax
cmp    $0xffffff9b,%eax
ja     119b <processo+0x5b>
lea    0xf23(%rip),%rdi
call   1030 <puts@plt>
mov    0x2e56(%rip),%rax
mov    (%rax),%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebp,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%r12
mov    %ebp,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,(%rsp)
mov    %ebp,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,0x10(%rsp)
mov    %ebp,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,0x8(%rsp)
mov    %ebp,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rbp
xor    %ebx,%ebx
xor    %r15d,%r15d
mov    %rax,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
lea    0xdf8(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    (%r12,%rbx,1),%rsi
lea    0xde0(%rip),%rbp
mov    %rbp,%rdi
call   1060 <scanf@plt>
lea    0xdf4(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%rsp),%rax
lea    (%rax,%rbx,1),%r13
mov    %rbp,%rdi
mov    %r13,%rsi
call   1060 <scanf@plt>
lea    0xdf0(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%rax
lea    (%rax,%rbx,1),%r14
mov    %rbp,%rdi
mov    %r14,%rsi
call   1060 <scanf@plt>
lea    0xdeb(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%rax
lea    (%rax,%rbx,1),%rbp
lea    0xdf1(%rip),%rdi
mov    %rbp,%rsi
call   1060 <scanf@plt>
mov    (%r12,%rbx,1),%eax
lea    -0x65(%rax),%ecx
cmp    $0xffffff9c,%ecx
jb     1177 <processo+0x37>
mov    0x0(%r13),%ecx
lea    -0x65(%rcx),%edx
cmp    $0xffffff9c,%edx
jb     1177 <processo+0x37>
mov    (%r14),%edx
lea    -0x65(%rdx),%esi
cmp    $0xffffff9c,%esi
jb     1177 <processo+0x37>
mov    0x0(%rbp),%esi
lea    -0x65(%rsi),%edi
cmp    $0xffffff9b,%edi
jbe    1177 <processo+0x37>
mov    %r12,%r9
sub    %eax,%ecx
sub    %edx,%esi
imul   %ecx,%esi
mov    0x20(%rsp),%rbp
mov    %esi,0x0(%rbp,%rbx,1)
movslq 0x1c(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%r15
jl     1200 <processo+0xc0>
mov    %eax,%ebx
cmp    $0x1,%ebx
jne    1327 <processo+0x1e7>
mov    (%rsp),%rax
mov    (%rax),%ecx
sub    (%r12),%ecx
mov    0x8(%rsp),%rax
mov    (%rax),%eax
mov    0x10(%rsp),%rdx
sub    (%rdx),%eax
imul   %ecx,%eax
mov    %eax,0x0(%rbp)
jmp    118c <processo+0x4c>
test   %ebx,%ebx
mov    (%rsp),%rdi
mov    0x10(%rsp),%r10
jle    1342 <processo+0x202>
cmp    $0x8,%ebx
jae    1349 <processo+0x209>
xor    %ecx,%ecx
xor    %eax,%eax
jmp    1440 <processo+0x300>
xor    %eax,%eax
jmp    118c <processo+0x4c>
mov    %ebx,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x18,%rdx
jae    1374 <processo+0x234>
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
jmp    13ea <processo+0x2aa>
and    $0xfffffffffffffffc,%rsi
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu 0x0(%rbp,%rdx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbp,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbp,%rdx,4),%xmm1
movdqu 0x30(%rbp,%rdx,4),%xmm3
movdqu 0x40(%rbp,%rdx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rbp,%rdx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rbp,%rdx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rbp,%rdx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1390 <processo+0x250>
test   %rax,%rax
je     141c <processo+0x2dc>
lea    0x10(,%rdx,4),%rdx
add    %rbp,%rdx
shl    $0x5,%rax
xor    %esi,%esi
movdqu -0x10(%rdx,%rsi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rdx,%rsi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rsi
cmp    %rsi,%rax
jne    1400 <processo+0x2c0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rbx,%rcx
je     144d <processo+0x30d>
nopl   0x0(%rax,%rax,1)
add    0x0(%rbp,%rcx,4),%eax
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1440 <processo+0x300>
cmp    $0x2,%ebx
jl     118c <processo+0x4c>
lea    -0x1(%rbx),%ecx
mov    %rcx,0x28(%rsp)
lea    -0x1(%rbx),%r14
xor    %r13d,%r13d
mov    %rbx,0x30(%rsp)
jmp    1485 <processo+0x345>
nopl   0x0(%rax)
mov    0x20(%rsp),%r13
cmp    0x28(%rsp),%r13
mov    0x30(%rsp),%rbx
je     118c <processo+0x4c>
lea    0x1(%r13),%rcx
cmp    %rbx,%rcx
mov    %rcx,0x20(%rsp)
jae    1470 <processo+0x330>
mov    (%r12,%r13,4),%r8d
mov    (%r10,%r13,4),%r15d
mov    %r13,%rbp
jmp    14b9 <processo+0x379>
mov    (%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %rbp,%r14
je     1470 <processo+0x330>
mov    0x4(%r12,%rbp,4),%esi
cmp    %r8d,%esi
jl     14cf <processo+0x38f>
mov    (%rdi,%r13,4),%ecx
cmp    %ecx,%esi
jle    1560 <processo+0x420>
mov    0x4(%r10,%rbp,4),%ebx
cmp    %ebx,%r15d
jg     14ea <processo+0x3aa>
mov    0x8(%rsp),%rcx
mov    (%rcx,%r13,4),%edx
cmp    %edx,%ebx
jle    15d0 <processo+0x490>
cmp    %r8d,%esi
jl     1670 <processo+0x530>
mov    (%rdi,%r13,4),%edx
mov    %edx,%ecx
sub    %esi,%ecx
jle    1670 <processo+0x530>
cmp    %edx,0x4(%rdi,%rbp,4)
jle    1670 <processo+0x530>
cmp    %ebx,%r15d
jle    1645 <processo+0x505>
mov    0x8(%rsp),%r11
mov    0x4(%r11,%rbp,4),%edi
mov    %r15d,%edx
sub    %edi,%edx
mov    (%r11,%r13,4),%r12d
imul   %ecx,%edx
cmp    %r12d,%edi
mov    $0x0,%r11d
cmovg  %r11d,%edx
cmp    %edi,%r15d
cmovge %r11d,%edx
add    %edx,%eax
cmp    %r12d,%edi
jle    1550 <processo+0x410>
mov    %r15d,%edx
sub    %r12d,%edx
imul   %ecx,%edx
add    %edx,%eax
mov    %r9,%r12
jmp    1660 <processo+0x520>
nopl   0x0(%rax,%rax,1)
mov    0x4(%rdi,%rbp,4),%ebx
cmp    %ebx,%r8d
jg     14cf <processo+0x38f>
cmp    %ecx,%ebx
jg     14cf <processo+0x38f>
sub    %esi,%ebx
mov    0x4(%r10,%rbp,4),%r11d
cmp    %r11d,%r15d
jle    16fd <processo+0x5bd>
mov    0x8(%rsp),%rcx
mov    0x4(%rcx,%rbp,4),%edx
mov    %r15d,%edi
sub    %edx,%edi
mov    (%rcx,%r13,4),%ecx
imul   %ebx,%edi
cmp    %ecx,%edx
mov    $0x0,%r11d
cmovg  %r11d,%edi
cmp    %edx,%r15d
cmovge %r11d,%edi
add    %edi,%eax
cmp    %ecx,%edx
jle    15bd <processo+0x47d>
mov    %r15d,%edx
sub    %ecx,%edx
imul   %ebx,%edx
add    %edx,%eax
mov    (%rsp),%rdi
jmp    14cf <processo+0x38f>
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rsp),%rcx
mov    0x4(%rcx,%rbp,4),%ecx
cmp    %ecx,%r15d
jg     14ea <processo+0x3aa>
cmp    %edx,%ecx
jg     14ea <processo+0x3aa>
mov    %esi,%edx
sub    %r8d,%edx
jg     1613 <processo+0x4d3>
mov    0x4(%rdi,%rbp,4),%r10d
cmp    %r10d,%r8d
jg     160e <processo+0x4ce>
cmp    (%rdi,%r13,4),%r10d
jg     160e <processo+0x4ce>
mov    %ecx,%edi
sub    %ebx,%edi
imul   %edx,%edi
add    %edi,%eax
mov    (%rsp),%rdi
mov    0x10(%rsp),%r10
cmp    %r8d,%esi
jl     1670 <processo+0x530>
mov    (%rdi,%r13,4),%edx
cmp    %edx,%esi
jg     14f7 <processo+0x3b7>
mov    %rdi,%r10
mov    %edx,%edi
sub    0x4(%r10,%rbp,4),%edi
jg     1637 <processo+0x4f7>
sub    %ebx,%ecx
imul   %ecx,%edi
add    %edi,%eax
mov    (%rsp),%rdi
mov    0x10(%rsp),%r10
jmp    14f7 <processo+0x3b7>
mov    0x8(%rsp),%r11
mov    (%r11,%r13,4),%edi
mov    %ebx,%edx
sub    %edi,%edx
jge    1660 <processo+0x520>
cmp    %edi,0x4(%r11,%rbp,4)
jle    1660 <processo+0x520>
imul   %ecx,%edx
add    %edx,%eax
mov    (%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x4(%rdi,%rbp,4),%edx
mov    %edx,%ecx
sub    %r8d,%ecx
jle    14b0 <processo+0x370>
cmp    (%rdi,%r13,4),%edx
jg     14b0 <processo+0x370>
cmp    %r8d,%esi
jge    14b0 <processo+0x370>
cmp    %ebx,%r15d
jle    169e <processo+0x55e>
mov    0x8(%rsp),%rdi
jmp    16c0 <processo+0x580>
mov    0x8(%rsp),%rdi
mov    (%rdi,%r13,4),%esi
mov    %ebx,%edx
sub    %esi,%edx
jge    16c0 <processo+0x580>
cmp    %esi,0x4(%rdi,%rbp,4)
jle    16c0 <processo+0x580>
imul   %ecx,%edx
add    %edx,%eax
nopl   0x0(%rax,%rax,1)
mov    0x4(%rdi,%rbp,4),%edx
mov    %rdi,%rsi
mov    %r15d,%edi
sub    %edx,%edi
jge    16da <processo+0x59a>
mov    (%rsi,%r13,4),%esi
cmp    %esi,%edx
jle    1767 <processo+0x627>
cmp    %ebx,%r15d
mov    (%rsp),%rdi
jle    14b0 <processo+0x370>
mov    0x8(%rsp),%rsi
mov    (%rsi,%r13,4),%esi
cmp    %esi,%edx
jle    14b0 <processo+0x370>
jmp    1781 <processo+0x641>
mov    0x8(%rsp),%rdx
mov    (%rdx,%r13,4),%r12d
cmp    %r12d,%r11d
jg     1724 <processo+0x5e4>
mov    0x4(%rdx,%rbp,4),%edi
mov    %r15d,%edx
sub    %edi,%edx
jg     1720 <processo+0x5e0>
cmp    %r12d,%edi
jg     1720 <processo+0x5e0>
imul   %ebx,%edx
add    %edx,%eax
mov    (%rsp),%rdi
mov    %r11d,%edx
sub    %r12d,%edx
jge    173d <processo+0x5fd>
mov    0x8(%rsp),%rcx
cmp    %r12d,0x4(%rcx,%rbp,4)
jle    173d <processo+0x5fd>
imul   %ebx,%edx
add    %edx,%eax
cmp    %r12d,%r11d
jg     175f <processo+0x61f>
mov    0x8(%rsp),%rdx
mov    0x4(%rdx,%rbp,4),%edx
cmp    %edx,%r15d
jg     175f <processo+0x61f>
cmp    %r12d,%edx
jg     175f <processo+0x61f>
sub    %edx,%r11d
imul   %ebx,%r11d
add    %r11d,%eax
mov    %r9,%r12
jmp    14cf <processo+0x38f>
cmp    %ebx,%r15d
jle    14a0 <processo+0x360>
imul   %ecx,%edi
add    %edi,%eax
mov    (%rsp),%rdi
cmp    %esi,%edx
jle    14b0 <processo+0x370>
mov    %r15d,%edx
sub    %esi,%edx
imul   %ecx,%edx
add    %edx,%eax
jmp    14b0 <processo+0x370>

LLVM IR (-O0):
@.str = [28 x i8] c"Digite o numero de redes: \0A\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [19 x i8] c"Error, try again.\0A\00"
@EXIT_FAILURE = global i32 0
@.str.3 = [32 x i8] c"Digite o valo de x0 da rede %d\0A\00"
@.str.4 = [32 x i8] c"Digite o valo de xf da rede %d\0A\00"
@.str.5 = [32 x i8] c"Digite o valo de y0 da rede %d\0A\00"
@.str.6 = [32 x i8] c"Digite o valo de yf da rede %d\0A\00"
@.str.7 = [3 x i8] c"%i\00"
define i32 @processo() {
%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 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
%14 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%15 = load i32, i32* %2
%16 = icmp slt i32 %15, 1
br i1 %16, label %20, label %17
17: ; preds = %0
%18 = load i32, i32* %2
%19 = icmp sgt i32 %18, 100
br i1 %19, label %20, label %23
20: ; preds = %17, %0
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
%22 = load i32, i32* @EXIT_FAILURE
store i32 %22, i32* %1
br label %1171
23: ; preds = %17
%24 = load i32, i32* %2
%25 = call i32* @calloc(i32 %24, i32 4)
store i32* %25, i32** %9
%26 = load i32, i32* %2
%27 = call i32* @calloc(i32 %26, i32 4)
store i32* %27, i32** %10
%28 = load i32, i32* %2
%29 = call i32* @calloc(i32 %28, i32 4)
store i32* %29, i32** %11
%30 = load i32, i32* %2
%31 = call i32* @calloc(i32 %30, i32 4)
store i32* %31, i32** %12
%32 = load i32, i32* %2
%33 = call i32* @calloc(i32 %32, i32 4)
store i32* %33, i32** %8
store i32 0, i32* %3
br label %34
34: ; preds = %129, %23
%35 = load i32, i32* %3
%36 = load i32, i32* %2
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %159
38: ; preds = %34
%39 = load i32, i32* %3
%40 = add nsw i32 %39, 1
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0), i32 %40)
%42 = load i32*, i32** %9
%43 = load i32, i32* %3
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %42, i64 %44
%46 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %45)
%47 = load i32, i32* %3
%48 = add nsw i32 %47, 1
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), i32 %48)
%50 = load i32*, i32** %10
%51 = load i32, i32* %3
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i32, i32* %50, i64 %52
%54 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %53)
%55 = load i32, i32* %3
%56 = add nsw i32 %55, 1
%57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.5, i64 0, i64 0), i32 %56)
%58 = load i32*, i32** %11
%59 = load i32, i32* %3
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %58, i64 %60
%62 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %61)
%63 = load i32, i32* %3
%64 = add nsw i32 %63, 1
%65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.6, i64 0, i64 0), i32 %64)
%66 = load i32*, i32** %12
%67 = load i32, i32* %3
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %66, i64 %68
%70 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32* %69)
%71 = load i32*, i32** %9
%72 = load i32, i32* %3
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %71, i64 %73
%75 = load i32, i32* %74
%76 = icmp slt i32 %75, 1
br i1 %76, label %126, label %77
77: ; preds = %38
%78 = load i32*, i32** %9
%79 = load i32, i32* %3
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %78, i64 %80
%82 = load i32, i32* %81
%83 = icmp sgt i32 %82, 100
br i1 %83, label %126, label %84
84: ; preds = %77
%85 = load i32*, i32** %10
%86 = load i32, i32* %3
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i32, i32* %85, i64 %87
%89 = load i32, i32* %88
%90 = icmp slt i32 %89, 1
br i1 %90, label %126, label %91
91: ; preds = %84
%92 = load i32*, i32** %10
%93 = load i32, i32* %3
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %92, i64 %94
%96 = load i32, i32* %95
%97 = icmp sgt i32 %96, 100
br i1 %97, label %126, label %98
98: ; preds = %91
%99 = load i32*, i32** %11
%100 = load i32, i32* %3
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %99, i64 %101
%103 = load i32, i32* %102
%104 = icmp slt i32 %103, 1
br i1 %104, label %126, label %105
105: ; preds = %98
%106 = load i32*, i32** %11
%107 = load i32, i32* %3
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %106, i64 %108
%110 = load i32, i32* %109
%111 = icmp sgt i32 %110, 100
br i1 %111, label %126, label %112
112: ; preds = %105
%113 = load i32*, i32** %12
%114 = load i32, i32* %3
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %113, i64 %115
%117 = load i32, i32* %116
%118 = icmp slt i32 %117, 1
br i1 %118, label %126, label %119
119: ; preds = %112
%120 = load i32*, i32** %12
%121 = load i32, i32* %3
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %120, i64 %122
%124 = load i32, i32* %123
%125 = icmp sgt i32 %124, 100
br i1 %125, label %126, label %129
126: ; preds = %119, %112, %105, %98, %91, %84, %77, %38
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
%128 = load i32, i32* @EXIT_FAILURE
store i32 %128, i32* %1
br label %1171
129: ; preds = %119
%130 = load i32*, i32** %10
%131 = load i32, i32* %3
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i32, i32* %130, i64 %132
%134 = load i32, i32* %133
%135 = load i32*, i32** %9
%136 = load i32, i32* %3
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds i32, i32* %135, i64 %137
%139 = load i32, i32* %138
%140 = sub nsw i32 %134, %139
%141 = load i32*, i32** %12
%142 = load i32, i32* %3
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %141, i64 %143
%145 = load i32, i32* %144
%146 = load i32*, i32** %11
%147 = load i32, i32* %3
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %146, i64 %148
%150 = load i32, i32* %149
%151 = sub nsw i32 %145, %150
%152 = mul nsw i32 %140, %151
%153 = load i32*, i32** %8
%154 = load i32, i32* %3
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
store i32 %152, i32* %156
%157 = load i32, i32* %3
%158 = add nsw i32 %157, 1
store i32 %158, i32* %3
br label %34
159: ; preds = %34
%160 = load i32, i32* %2
%161 = icmp eq i32 %160, 1
br i1 %161, label %162, label %183
162: ; preds = %159
%163 = load i32*, i32** %10
%164 = getelementptr inbounds i32, i32* %163, i64 0
%165 = load i32, i32* %164
%166 = load i32*, i32** %9
%167 = getelementptr inbounds i32, i32* %166, i64 0
%168 = load i32, i32* %167
%169 = sub nsw i32 %165, %168
%170 = load i32*, i32** %12
%171 = getelementptr inbounds i32, i32* %170, i64 0
%172 = load i32, i32* %171
%173 = load i32*, i32** %11
%174 = getelementptr inbounds i32, i32* %173, i64 0
%175 = load i32, i32* %174
%176 = sub nsw i32 %172, %175
%177 = mul nsw i32 %169, %176
%178 = load i32*, i32** %8
%179 = getelementptr inbounds i32, i32* %178, i64 0
store i32 %177, i32* %179
%180 = load i32*, i32** %8
%181 = getelementptr inbounds i32, i32* %180, i64 0
%182 = load i32, i32* %181
store i32 %182, i32* %1
br label %1171
183: ; preds = %159
store i32 0, i32* %3
store i32 0, i32* %7
br label %184
184: ; preds = %188, %183
%185 = load i32, i32* %3
%186 = load i32, i32* %2
%187 = icmp slt i32 %185, %186
br i1 %187, label %188, label %198
188: ; preds = %184
%189 = load i32, i32* %7
%190 = load i32*, i32** %8
%191 = load i32, i32* %3
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i32, i32* %190, i64 %192
%194 = load i32, i32* %193
%195 = add nsw i32 %189, %194
store i32 %195, i32* %7
%196 = load i32, i32* %3
%197 = add nsw i32 %196, 1
store i32 %197, i32* %3
br label %184
198: ; preds = %184
store i32 0, i32* %3
store i32 0, i32* %3
br label %199
199: ; preds = %1166, %198
%200 = load i32, i32* %3
%201 = load i32, i32* %2
%202 = sub nsw i32 %201, 1
%203 = icmp slt i32 %200, %202
br i1 %203, label %204, label %1169
204: ; preds = %199
%205 = load i32, i32* %3
%206 = add nsw i32 %205, 1
store i32 %206, i32* %4
br label %207
207: ; preds = %1162, %204
%208 = load i32, i32* %4
%209 = load i32, i32* %2
%210 = icmp slt i32 %208, %209
br i1 %210, label %211, label %1165
211: ; preds = %207
%212 = load i32*, i32** %9
%213 = load i32, i32* %3
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i32, i32* %212, i64 %214
%216 = load i32, i32* %215
%217 = load i32*, i32** %9
%218 = load i32, i32* %4
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i32, i32* %217, i64 %219
%221 = load i32, i32* %220
%222 = icmp sle i32 %216, %221
br i1 %222, label %223, label %548
223: ; preds = %211
%224 = load i32*, i32** %9
%225 = load i32, i32* %4
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i32, i32* %224, i64 %226
%228 = load i32, i32* %227
%229 = load i32*, i32** %10
%230 = load i32, i32* %3
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i32, i32* %229, i64 %231
%233 = load i32, i32* %232
%234 = icmp sle i32 %228, %233
br i1 %234, label %235, label %548
235: ; preds = %223
%236 = load i32*, i32** %9
%237 = load i32, i32* %3
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i32, i32* %236, i64 %238
%240 = load i32, i32* %239
%241 = load i32*, i32** %10
%242 = load i32, i32* %4
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i32, i32* %241, i64 %243
%245 = load i32, i32* %244
%246 = icmp sle i32 %240, %245
br i1 %246, label %247, label %548
247: ; preds = %235
%248 = load i32*, i32** %10
%249 = load i32, i32* %4
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i32, i32* %248, i64 %250
%252 = load i32, i32* %251
%253 = load i32*, i32** %10
%254 = load i32, i32* %3
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds i32, i32* %253, i64 %255
%257 = load i32, i32* %256
%258 = icmp sle i32 %252, %257
br i1 %258, label %259, label %548
259: ; preds = %247
%260 = load i32*, i32** %10
%261 = load i32, i32* %4
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i32, i32* %260, i64 %262
%264 = load i32, i32* %263
%265 = load i32*, i32** %9
%266 = load i32, i32* %4
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %265, i64 %267
%269 = load i32, i32* %268
%270 = sub nsw i32 %264, %269
store i32 %270, i32* %5
%271 = load i32*, i32** %11
%272 = load i32, i32* %3
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds i32, i32* %271, i64 %273
%275 = load i32, i32* %274
%276 = load i32*, i32** %11
%277 = load i32, i32* %4
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i32, i32* %276, i64 %278
%280 = load i32, i32* %279
%281 = icmp sle i32 %275, %280
br i1 %281, label %282, label %335
282: ; preds = %259
%283 = load i32*, i32** %11
%284 = load i32, i32* %4
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32, i32* %283, i64 %285
%287 = load i32, i32* %286
%288 = load i32*, i32** %12
%289 = load i32, i32* %3
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i32, i32* %288, i64 %290
%292 = load i32, i32* %291
%293 = icmp sle i32 %287, %292
br i1 %293, label %294, label %335
294: ; preds = %282
%295 = load i32*, i32** %11
%296 = load i32, i32* %3
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i32, i32* %295, i64 %297
%299 = load i32, i32* %298
%300 = load i32*, i32** %12
%301 = load i32, i32* %4
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i32, i32* %300, i64 %302
%304 = load i32, i32* %303
%305 = icmp sle i32 %299, %304
br i1 %305, label %306, label %335
306: ; preds = %294
%307 = load i32*, i32** %12
%308 = load i32, i32* %4
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds i32, i32* %307, i64 %309
%311 = load i32, i32* %310
%312 = load i32*, i32** %12
%313 = load i32, i32* %3
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %312, i64 %314
%316 = load i32, i32* %315
%317 = icmp sle i32 %311, %316
br i1 %317, label %318, label %335
318: ; preds = %306
%319 = load i32*, i32** %12
%320 = load i32, i32* %4
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds i32, i32* %319, i64 %321
%323 = load i32, i32* %322
%324 = load i32*, i32** %11
%325 = load i32, i32* %3
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %324, i64 %326
%328 = load i32, i32* %327
%329 = sub nsw i32 %323, %328
store i32 %329, i32* %6
%330 = load i32, i32* %7
%331 = load i32, i32* %5
%332 = load i32, i32* %6
%333 = mul nsw i32 %331, %332
%334 = sub nsw i32 %330, %333
store i32 %334, i32* %7
br label %335
335: ; preds = %318, %306, %294, %282, %259
%336 = load i32*, i32** %11
%337 = load i32, i32* %4
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i32, i32* %336, i64 %338
%340 = load i32, i32* %339
%341 = load i32*, i32** %11
%342 = load i32, i32* %3
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds i32, i32* %341, i64 %343
%345 = load i32, i32* %344
%346 = icmp slt i32 %340, %345
br i1 %346, label %347, label %388
347: ; preds = %335
%348 = load i32*, i32** %11
%349 = load i32, i32* %3
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds i32, i32* %348, i64 %350
%352 = load i32, i32* %351
%353 = load i32*, i32** %12
%354 = load i32, i32* %4
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds i32, i32* %353, i64 %355
%357 = load i32, i32* %356
%358 = icmp slt i32 %352, %357
br i1 %358, label %359, label %388
359: ; preds = %347
%360 = load i32*, i32** %12
%361 = load i32, i32* %4
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds i32, i32* %360, i64 %362
%364 = load i32, i32* %363
%365 = load i32*, i32** %12
%366 = load i32, i32* %3
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i32, i32* %365, i64 %367
%369 = load i32, i32* %368
%370 = icmp sle i32 %364, %369
br i1 %370, label %371, label %388
371: ; preds = %359
%372 = load i32*, i32** %12
%373 = load i32, i32* %4
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %372, i64 %374
%376 = load i32, i32* %375
%377 = load i32*, i32** %11
%378 = load i32, i32* %3
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %377, i64 %379
%381 = load i32, i32* %380
%382 = sub nsw i32 %376, %381
store i32 %382, i32* %6
%383 = load i32, i32* %7
%384 = load i32, i32* %5
%385 = load i32, i32* %6
%386 = mul nsw i32 %384, %385
%387 = sub nsw i32 %383, %386
store i32 %387, i32* %7
br label %388
388: ; preds = %371, %359, %347, %335
%389 = load i32*, i32** %11
%390 = load i32, i32* %3
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i32, i32* %389, i64 %391
%393 = load i32, i32* %392
%394 = load i32*, i32** %11
%395 = load i32, i32* %4
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds i32, i32* %394, i64 %396
%398 = load i32, i32* %397
%399 = icmp sle i32 %393, %398
br i1 %399, label %400, label %441
400: ; preds = %388
%401 = load i32*, i32** %11
%402 = load i32, i32* %4
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds i32, i32* %401, i64 %403
%405 = load i32, i32* %404
%406 = load i32*, i32** %12
%407 = load i32, i32* %3
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32, i32* %406, i64 %408
%410 = load i32, i32* %409
%411 = icmp slt i32 %405, %410
br i1 %411, label %412, label %441
412: ; preds = %400
%413 = load i32*, i32** %12
%414 = load i32, i32* %4
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i32, i32* %413, i64 %415
%417 = load i32, i32* %416
%418 = load i32*, i32** %12
%419 = load i32, i32* %3
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds i32, i32* %418, i64 %420
%422 = load i32, i32* %421
%423 = icmp sgt i32 %417, %422
br i1 %423, label %424, label %441
424: ; preds = %412
%425 = load i32*, i32** %12
%426 = load i32, i32* %3
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds i32, i32* %425, i64 %427
%429 = load i32, i32* %428
%430 = load i32*, i32** %11
%431 = load i32, i32* %4
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds i32, i32* %430, i64 %432
%434 = load i32, i32* %433
%435 = sub nsw i32 %429, %434
store i32 %435, i32* %6
%436 = load i32, i32* %7
%437 = load i32, i32* %5
%438 = load i32, i32* %6
%439 = mul nsw i32 %437, %438
%440 = sub nsw i32 %436, %439
store i32 %440, i32* %7
br label %441
441: ; preds = %424, %412, %400, %388
%442 = load i32*, i32** %11
%443 = load i32, i32* %3
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds i32, i32* %442, i64 %444
%446 = load i32, i32* %445
%447 = load i32*, i32** %11
%448 = load i32, i32* %4
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds i32, i32* %447, i64 %449
%451 = load i32, i32* %450
%452 = icmp sle i32 %446, %451
br i1 %452, label %453, label %506
453: ; preds = %441
%454 = load i32*, i32** %11
%455 = load i32, i32* %4
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i32, i32* %454, i64 %456
%458 = load i32, i32* %457
%459 = load i32*, i32** %12
%460 = load i32, i32* %3
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds i32, i32* %459, i64 %461
%463 = load i32, i32* %462
%464 = icmp sle i32 %458, %463
br i1 %464, label %465, label %506
465: ; preds = %453
%466 = load i32*, i32** %11
%467 = load i32, i32* %3
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds i32, i32* %466, i64 %468
%470 = load i32, i32* %469
%471 = load i32*, i32** %12
%472 = load i32, i32* %4
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds i32, i32* %471, i64 %473
%475 = load i32, i32* %474
%476 = icmp sle i32 %470, %475
br i1 %476, label %477, label %506
477: ; preds = %465
%478 = load i32*, i32** %12
%479 = load i32, i32* %4
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds i32, i32* %478, i64 %480
%482 = load i32, i32* %481
%483 = load i32*, i32** %12
%484 = load i32, i32* %3
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i32, i32* %483, i64 %485
%487 = load i32, i32* %486
%488 = icmp sle i32 %482, %487
br i1 %488, label %489, label %506
489: ; preds = %477
%490 = load i32*, i32** %12
%491 = load i32, i32* %4
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds i32, i32* %490, i64 %492
%494 = load i32, i32* %493
%495 = load i32*, i32** %11
%496 = load i32, i32* %4
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds i32, i32* %495, i64 %497
%499 = load i32, i32* %498
%500 = sub nsw i32 %494, %499
store i32 %500, i32* %6
%501 = load i32, i32* %7
%502 = load i32, i32* %5
%503 = load i32, i32* %6
%504 = mul nsw i32 %502, %503
%505 = sub nsw i32 %501, %504
store i32 %505, i32* %7
br label %506
506: ; preds = %489, %477, %465, %453, %441
%507 = load i32*, i32** %11
%508 = load i32, i32* %4
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds i32, i32* %507, i64 %509
%511 = load i32, i32* %510
%512 = load i32*, i32** %11
%513 = load i32, i32* %3
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds i32, i32* %512, i64 %514
%516 = load i32, i32* %515
%517 = icmp slt i32 %511, %516
br i1 %517, label %518, label %547
518: ; preds = %506
%519 = load i32*, i32** %12
%520 = load i32, i32* %4
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds i32, i32* %519, i64 %521
%523 = load i32, i32* %522
%524 = load i32*, i32** %12
%525 = load i32, i32* %3
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds i32, i32* %524, i64 %526
%528 = load i32, i32* %527
%529 = icmp sgt i32 %523, %528
br i1 %529, label %530, label %547
530: ; preds = %518
%531 = load i32*, i32** %12
%532 = load i32, i32* %3
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i32, i32* %531, i64 %533
%535 = load i32, i32* %534
%536 = load i32*, i32** %11
%537 = load i32, i32* %3
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds i32, i32* %536, i64 %538
%540 = load i32, i32* %539
%541 = sub nsw i32 %535, %540
store i32 %541, i32* %6
%542 = load i32, i32* %7
%543 = load i32, i32* %5
%544 = load i32, i32* %6
%545 = mul nsw i32 %543, %544
%546 = sub nsw i32 %542, %545
store i32 %546, i32* %7
br label %547
547: ; preds = %530, %518, %506
br label %548
548: ; preds = %547, %247, %235, %223, %211
%549 = load i32*, i32** %11
%550 = load i32, i32* %3
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds i32, i32* %549, i64 %551
%553 = load i32, i32* %552
%554 = load i32*, i32** %11
%555 = load i32, i32* %4
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds i32, i32* %554, i64 %556
%558 = load i32, i32* %557
%559 = icmp sle i32 %553, %558
br i1 %559, label %560, label %771
560: ; preds = %548
%561 = load i32*, i32** %11
%562 = load i32, i32* %4
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds i32, i32* %561, i64 %563
%565 = load i32, i32* %564
%566 = load i32*, i32** %12
%567 = load i32, i32* %3
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds i32, i32* %566, i64 %568
%570 = load i32, i32* %569
%571 = icmp sle i32 %565, %570
br i1 %571, label %572, label %771
572: ; preds = %560
%573 = load i32*, i32** %11
%574 = load i32, i32* %3
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds i32, i32* %573, i64 %575
%577 = load i32, i32* %576
%578 = load i32*, i32** %12
%579 = load i32, i32* %4
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds i32, i32* %578, i64 %580
%582 = load i32, i32* %581
%583 = icmp sle i32 %577, %582
br i1 %583, label %584, label %771
584: ; preds = %572
%585 = load i32*, i32** %12
%586 = load i32, i32* %4
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds i32, i32* %585, i64 %587
%589 = load i32, i32* %588
%590 = load i32*, i32** %12
%591 = load i32, i32* %3
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds i32, i32* %590, i64 %592
%594 = load i32, i32* %593
%595 = icmp sle i32 %589, %594
br i1 %595, label %596, label %771
596: ; preds = %584
%597 = load i32*, i32** %9
%598 = load i32, i32* %3
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds i32, i32* %597, i64 %599
%601 = load i32, i32* %600
%602 = load i32*, i32** %9
%603 = load i32, i32* %4
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds i32, i32* %602, i64 %604
%606 = load i32, i32* %605
%607 = icmp sle i32 %601, %606
br i1 %607, label %608, label %646
608: ; preds = %596
%609 = load i32*, i32** %9
%610 = load i32, i32* %4
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds i32, i32* %609, i64 %611
%613 = load i32, i32* %612
%614 = load i32*, i32** %10
%615 = load i32, i32* %3
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds i32, i32* %614, i64 %616
%618 = load i32, i32* %617
%619 = icmp sle i32 %613, %618
br i1 %619, label %620, label %646
620: ; preds = %608
%621 = load i32*, i32** %9
%622 = load i32, i32* %3
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds i32, i32* %621, i64 %623
%625 = load i32, i32* %624
%626 = load i32*, i32** %10
%627 = load i32, i32* %4
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds i32, i32* %626, i64 %628
%630 = load i32, i32* %629
%631 = icmp sle i32 %625, %630
br i1 %631, label %632, label %646
632: ; preds = %620
%633 = load i32*, i32** %10
%634 = load i32, i32* %4
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds i32, i32* %633, i64 %635
%637 = load i32, i32* %636
%638 = load i32*, i32** %10
%639 = load i32, i32* %3
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds i32, i32* %638, i64 %640
%642 = load i32, i32* %641
%643 = icmp sle i32 %637, %642
br i1 %643, label %644, label %646
644: ; preds = %632
%645 = load i32, i32* %7
store i32 %645, i32* %7
br label %646
646: ; preds = %644, %632, %620, %608, %596
%647 = load i32*, i32** %9
%648 = load i32, i32* %4
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds i32, i32* %647, i64 %649
%651 = load i32, i32* %650
%652 = load i32*, i32** %9
%653 = load i32, i32* %3
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds i32, i32* %652, i64 %654
%656 = load i32, i32* %655
%657 = icmp sle i32 %651, %656
br i1 %657, label %658, label %708
658: ; preds = %646
%659 = load i32*, i32** %9
%660 = load i32, i32* %3
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds i32, i32* %659, i64 %661
%663 = load i32, i32* %662
%664 = load i32*, i32** %10
%665 = load i32, i32* %4
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds i32, i32* %664, i64 %666
%668 = load i32, i32* %667
%669 = icmp sle i32 %663, %668
br i1 %669, label %670, label %708
670: ; preds = %658
%671 = load i32*, i32** %10
%672 = load i32, i32* %4
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds i32, i32* %671, i64 %673
%675 = load i32, i32* %674
%676 = load i32*, i32** %10
%677 = load i32, i32* %3
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds i32, i32* %676, i64 %678
%680 = load i32, i32* %679
%681 = icmp sle i32 %675, %680
br i1 %681, label %682, label %708
682: ; preds = %670
%683 = load i32, i32* %7
%684 = load i32*, i32** %12
%685 = load i32, i32* %4
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds i32, i32* %684, i64 %686
%688 = load i32, i32* %687
%689 = load i32*, i32** %11
%690 = load i32, i32* %4
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds i32, i32* %689, i64 %691
%693 = load i32, i32* %692
%694 = sub nsw i32 %688, %693
%695 = load i32*, i32** %9
%696 = load i32, i32* %3
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds i32, i32* %695, i64 %697
%699 = load i32, i32* %698
%700 = load i32*, i32** %9
%701 = load i32, i32* %4
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds i32, i32* %700, i64 %702
%704 = load i32, i32* %703
%705 = sub nsw i32 %699, %704
%706 = mul nsw i32 %694, %705
%707 = sub nsw i32 %683, %706
store i32 %707, i32* %7
br label %708
708: ; preds = %682, %670, %658, %646
%709 = load i32*, i32** %9
%710 = load i32, i32* %3
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds i32, i32* %709, i64 %711
%713 = load i32, i32* %712
%714 = load i32*, i32** %9
%715 = load i32, i32* %4
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds i32, i32* %714, i64 %716
%718 = load i32, i32* %717
%719 = icmp sle i32 %713, %718
br i1 %719, label %720, label %770
720: ; preds = %708
%721 = load i32*, i32** %9
%722 = load i32, i32* %4
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds i32, i32* %721, i64 %723
%725 = load i32, i32* %724
%726 = load i32*, i32** %10
%727 = load i32, i32* %3
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds i32, i32* %726, i64 %728
%730 = load i32, i32* %729
%731 = icmp sle i32 %725, %730
br i1 %731, label %732, label %770
732: ; preds = %720
%733 = load i32*, i32** %10
%734 = load i32, i32* %4
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds i32, i32* %733, i64 %735
%737 = load i32, i32* %736
%738 = load i32*, i32** %10
%739 = load i32, i32* %3
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds i32, i32* %738, i64 %740
%742 = load i32, i32* %741
%743 = icmp sge i32 %737, %742
br i1 %743, label %744, label %770
744: ; preds = %732
%745 = load i32, i32* %7
%746 = load i32*, i32** %12
%747 = load i32, i32* %4
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds i32, i32* %746, i64 %748
%750 = load i32, i32* %749
%751 = load i32*, i32** %11
%752 = load i32, i32* %4
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds i32, i32* %751, i64 %753
%755 = load i32, i32* %754
%756 = sub nsw i32 %750, %755
%757 = load i32*, i32** %10
%758 = load i32, i32* %4
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds i32, i32* %757, i64 %759
%761 = load i32, i32* %760
%762 = load i32*, i32** %10
%763 = load i32, i32* %3
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds i32, i32* %762, i64 %764
%766 = load i32, i32* %765
%767 = sub nsw i32 %761, %766
%768 = mul nsw i32 %756, %767
%769 = sub nsw i32 %745, %768
store i32 %769, i32* %7
br label %770
770: ; preds = %744, %732, %720, %708
br label %771
771: ; preds = %770, %584, %572, %560, %548
%772 = load i32*, i32** %9
%773 = load i32, i32* %3
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds i32, i32* %772, i64 %774
%776 = load i32, i32* %775
%777 = load i32*, i32** %9
%778 = load i32, i32* %4
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds i32, i32* %777, i64 %779
%781 = load i32, i32* %780
%782 = icmp sle i32 %776, %781
br i1 %782, label %783, label %966
783: ; preds = %771
%784 = load i32*, i32** %9
%785 = load i32, i32* %4
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds i32, i32* %784, i64 %786
%788 = load i32, i32* %787
%789 = load i32*, i32** %10
%790 = load i32, i32* %3
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds i32, i32* %789, i64 %791
%793 = load i32, i32* %792
%794 = icmp slt i32 %788, %793
br i1 %794, label %795, label %966
795: ; preds = %783
%796 = load i32*, i32** %10
%797 = load i32, i32* %4
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds i32, i32* %796, i64 %798
%800 = load i32, i32* %799
%801 = load i32*, i32** %10
%802 = load i32, i32* %3
%803 = sext i32 %802 to i64
%804 = getelementptr inbounds i32, i32* %801, i64 %803
%805 = load i32, i32* %804
%806 = icmp sgt i32 %800, %805
br i1 %806, label %807, label %966
807: ; preds = %795
%808 = load i32*, i32** %10
%809 = load i32, i32* %3
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds i32, i32* %808, i64 %810
%812 = load i32, i32* %811
%813 = load i32*, i32** %9
%814 = load i32, i32* %4
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds i32, i32* %813, i64 %815
%817 = load i32, i32* %816
%818 = sub nsw i32 %812, %817
store i32 %818, i32* %5
%819 = load i32*, i32** %11
%820 = load i32, i32* %3
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds i32, i32* %819, i64 %821
%823 = load i32, i32* %822
%824 = load i32*, i32** %11
%825 = load i32, i32* %4
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds i32, i32* %824, i64 %826
%828 = load i32, i32* %827
%829 = icmp sle i32 %823, %828
br i1 %829, label %830, label %871
830: ; preds = %807
%831 = load i32*, i32** %11
%832 = load i32, i32* %4
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds i32, i32* %831, i64 %833
%835 = load i32, i32* %834
%836 = load i32*, i32** %12
%837 = load i32, i32* %3
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds i32, i32* %836, i64 %838
%840 = load i32, i32* %839
%841 = icmp slt i32 %835, %840
br i1 %841, label %842, label %871
842: ; preds = %830
%843 = load i32*, i32** %12
%844 = load i32, i32* %4
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds i32, i32* %843, i64 %845
%847 = load i32, i32* %846
%848 = load i32*, i32** %12
%849 = load i32, i32* %3
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds i32, i32* %848, i64 %850
%852 = load i32, i32* %851
%853 = icmp sgt i32 %847, %852
br i1 %853, label %854, label %871
854: ; preds = %842
%855 = load i32*, i32** %12
%856 = load i32, i32* %3
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds i32, i32* %855, i64 %857
%859 = load i32, i32* %858
%860 = load i32*, i32** %11
%861 = load i32, i32* %4
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds i32, i32* %860, i64 %862
%864 = load i32, i32* %863
%865 = sub nsw i32 %859, %864
store i32 %865, i32* %6
%866 = load i32, i32* %7
%867 = load i32, i32* %5
%868 = load i32, i32* %6
%869 = mul nsw i32 %867, %868
%870 = sub nsw i32 %866, %869
store i32 %870, i32* %7
br label %871
871: ; preds = %854, %842, %830, %807
%872 = load i32*, i32** %11
%873 = load i32, i32* %3
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds i32, i32* %872, i64 %874
%876 = load i32, i32* %875
%877 = load i32*, i32** %11
%878 = load i32, i32* %4
%879 = sext i32 %878 to i64
%880 = getelementptr inbounds i32, i32* %877, i64 %879
%881 = load i32, i32* %880
%882 = icmp sgt i32 %876, %881
br i1 %882, label %883, label %924
883: ; preds = %871
%884 = load i32*, i32** %11
%885 = load i32, i32* %3
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds i32, i32* %884, i64 %886
%888 = load i32, i32* %887
%889 = load i32*, i32** %12
%890 = load i32, i32* %4
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds i32, i32* %889, i64 %891
%893 = load i32, i32* %892
%894 = icmp slt i32 %888, %893
br i1 %894, label %895, label %924
895: ; preds = %883
%896 = load i32*, i32** %12
%897 = load i32, i32* %4
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds i32, i32* %896, i64 %898
%900 = load i32, i32* %899
%901 = load i32*, i32** %12
%902 = load i32, i32* %3
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds i32, i32* %901, i64 %903
%905 = load i32, i32* %904
%906 = icmp sle i32 %900, %905
br i1 %906, label %907, label %924
907: ; preds = %895
%908 = load i32*, i32** %12
%909 = load i32, i32* %4
%910 = sext i32 %909 to i64
%911 = getelementptr inbounds i32, i32* %908, i64 %910
%912 = load i32, i32* %911
%913 = load i32*, i32** %11
%914 = load i32, i32* %3
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds i32, i32* %913, i64 %915
%917 = load i32, i32* %916
%918 = sub nsw i32 %912, %917
store i32 %918, i32* %6
%919 = load i32, i32* %7
%920 = load i32, i32* %5
%921 = load i32, i32* %6
%922 = mul nsw i32 %920, %921
%923 = sub nsw i32 %919, %922
store i32 %923, i32* %7
br label %924
924: ; preds = %907, %895, %883, %871
%925 = load i32*, i32** %11
%926 = load i32, i32* %3
%927 = sext i32 %926 to i64
%928 = getelementptr inbounds i32, i32* %925, i64 %927
%929 = load i32, i32* %928
%930 = load i32*, i32** %11
%931 = load i32, i32* %4
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds i32, i32* %930, i64 %932
%934 = load i32, i32* %933
%935 = icmp sgt i32 %929, %934
br i1 %935, label %936, label %965
936: ; preds = %924
%937 = load i32*, i32** %12
%938 = load i32, i32* %4
%939 = sext i32 %938 to i64
%940 = getelementptr inbounds i32, i32* %937, i64 %939
%941 = load i32, i32* %940
%942 = load i32*, i32** %12
%943 = load i32, i32* %3
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds i32, i32* %942, i64 %944
%946 = load i32, i32* %945
%947 = icmp sgt i32 %941, %946
br i1 %947, label %948, label %965
948: ; preds = %936
%949 = load i32*, i32** %12
%950 = load i32, i32* %3
%951 = sext i32 %950 to i64
%952 = getelementptr inbounds i32, i32* %949, i64 %951
%953 = load i32, i32* %952
%954 = load i32*, i32** %11
%955 = load i32, i32* %3
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds i32, i32* %954, i64 %956
%958 = load i32, i32* %957
%959 = sub nsw i32 %953, %958
store i32 %959, i32* %6
%960 = load i32, i32* %7
%961 = load i32, i32* %5
%962 = load i32, i32* %6
%963 = mul nsw i32 %961, %962
%964 = sub nsw i32 %960, %963
store i32 %964, i32* %7
br label %965
965: ; preds = %948, %936, %924
br label %966
966: ; preds = %965, %795, %783, %771
%967 = load i32*, i32** %9
%968 = load i32, i32* %3
%969 = sext i32 %968 to i64
%970 = getelementptr inbounds i32, i32* %967, i64 %969
%971 = load i32, i32* %970
%972 = load i32*, i32** %10
%973 = load i32, i32* %4
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds i32, i32* %972, i64 %974
%976 = load i32, i32* %975
%977 = icmp slt i32 %971, %976
br i1 %977, label %978, label %1161
978: ; preds = %966
%979 = load i32*, i32** %10
%980 = load i32, i32* %4
%981 = sext i32 %980 to i64
%982 = getelementptr inbounds i32, i32* %979, i64 %981
%983 = load i32, i32* %982
%984 = load i32*, i32** %10
%985 = load i32, i32* %3
%986 = sext i32 %985 to i64
%987 = getelementptr inbounds i32, i32* %984, i64 %986
%988 = load i32, i32* %987
%989 = icmp sle i32 %983, %988
br i1 %989, label %990, label %1161
990: ; preds = %978
%991 = load i32*, i32** %9
%992 = load i32, i32* %3
%993 = sext i32 %992 to i64
%994 = getelementptr inbounds i32, i32* %991, i64 %993
%995 = load i32, i32* %994
%996 = load i32*, i32** %9
%997 = load i32, i32* %4
%998 = sext i32 %997 to i64
%999 = getelementptr inbounds i32, i32* %996, i64 %998
%1000 = load i32, i32* %999
%1001 = icmp sgt i32 %995, %1000
br i1 %1001, label %1002, label %1161
1002: ; preds = %990
%1003 = load i32*, i32** %10
%1004 = load i32, i32* %4
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds i32, i32* %1003, i64 %1005
%1007 = load i32, i32* %1006
%1008 = load i32*, i32** %9
%1009 = load i32, i32* %3
%1010 = sext i32 %1009 to i64
%1011 = getelementptr inbounds i32, i32* %1008, i64 %1010
%1012 = load i32, i32* %1011
%1013 = sub nsw i32 %1007, %1012
store i32 %1013, i32* %5
%1014 = load i32*, i32** %11
%1015 = load i32, i32* %3
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds i32, i32* %1014, i64 %1016
%1018 = load i32, i32* %1017
%1019 = load i32*, i32** %11
%1020 = load i32, i32* %4
%1021 = sext i32 %1020 to i64
%1022 = getelementptr inbounds i32, i32* %1019, i64 %1021
%1023 = load i32, i32* %1022
%1024 = icmp sle i32 %1018, %1023
br i1 %1024, label %1025, label %1066
1025: ; preds = %1002
%1026 = load i32*, i32** %11
%1027 = load i32, i32* %4
%1028 = sext i32 %1027 to i64
%1029 = getelementptr inbounds i32, i32* %1026, i64 %1028
%1030 = load i32, i32* %1029
%1031 = load i32*, i32** %12
%1032 = load i32, i32* %3
%1033 = sext i32 %1032 to i64
%1034 = getelementptr inbounds i32, i32* %1031, i64 %1033
%1035 = load i32, i32* %1034
%1036 = icmp slt i32 %1030, %1035
br i1 %1036, label %1037, label %1066
1037: ; preds = %1025
%1038 = load i32*, i32** %12
%1039 = load i32, i32* %4
%1040 = sext i32 %1039 to i64
%1041 = getelementptr inbounds i32, i32* %1038, i64 %1040
%1042 = load i32, i32* %1041
%1043 = load i32*, i32** %12
%1044 = load i32, i32* %3
%1045 = sext i32 %1044 to i64
%1046 = getelementptr inbounds i32, i32* %1043, i64 %1045
%1047 = load i32, i32* %1046
%1048 = icmp sgt i32 %1042, %1047
br i1 %1048, label %1049, label %1066
1049: ; preds = %1037
%1050 = load i32*, i32** %12
%1051 = load i32, i32* %3
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds i32, i32* %1050, i64 %1052
%1054 = load i32, i32* %1053
%1055 = load i32*, i32** %11
%1056 = load i32, i32* %4
%1057 = sext i32 %1056 to i64
%1058 = getelementptr inbounds i32, i32* %1055, i64 %1057
%1059 = load i32, i32* %1058
%1060 = sub nsw i32 %1054, %1059
store i32 %1060, i32* %6
%1061 = load i32, i32* %7
%1062 = load i32, i32* %5
%1063 = load i32, i32* %6
%1064 = mul nsw i32 %1062, %1063
%1065 = sub nsw i32 %1061, %1064
store i32 %1065, i32* %7
br label %1066
1066: ; preds = %1049, %1037, %1025, %1002
%1067 = load i32*, i32** %11
%1068 = load i32, i32* %3
%1069 = sext i32 %1068 to i64
%1070 = getelementptr inbounds i32, i32* %1067, i64 %1069
%1071 = load i32, i32* %1070
%1072 = load i32*, i32** %12
%1073 = load i32, i32* %4
%1074 = sext i32 %1073 to i64
%1075 = getelementptr inbounds i32, i32* %1072, i64 %1074
%1076 = load i32, i32* %1075
%1077 = icmp slt i32 %1071, %1076
br i1 %1077, label %1078, label %1119
1078: ; preds = %1066
%1079 = load i32*, i32** %12
%1080 = load i32, i32* %4
%1081 = sext i32 %1080 to i64
%1082 = getelementptr inbounds i32, i32* %1079, i64 %1081
%1083 = load i32, i32* %1082
%1084 = load i32*, i32** %12
%1085 = load i32, i32* %3
%1086 = sext i32 %1085 to i64
%1087 = getelementptr inbounds i32, i32* %1084, i64 %1086
%1088 = load i32, i32* %1087
%1089 = icmp sle i32 %1083, %1088
br i1 %1089, label %1090, label %1119
1090: ; preds = %1078
%1091 = load i32*, i32** %11
%1092 = load i32, i32* %3
%1093 = sext i32 %1092 to i64
%1094 = getelementptr inbounds i32, i32* %1091, i64 %1093
%1095 = load i32, i32* %1094
%1096 = load i32*, i32** %11
%1097 = load i32, i32* %4
%1098 = sext i32 %1097 to i64
%1099 = getelementptr inbounds i32, i32* %1096, i64 %1098
%1100 = load i32, i32* %1099
%1101 = icmp sgt i32 %1095, %1100
br i1 %1101, label %1102, label %1119
1102: ; preds = %1090
%1103 = load i32*, i32** %12
%1104 = load i32, i32* %4
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds i32, i32* %1103, i64 %1105
%1107 = load i32, i32* %1106
%1108 = load i32*, i32** %11
%1109 = load i32, i32* %3
%1110 = sext i32 %1109 to i64
%1111 = getelementptr inbounds i32, i32* %1108, i64 %1110
%1112 = load i32, i32* %1111
%1113 = sub nsw i32 %1107, %1112
store i32 %1113, i32* %6
%1114 = load i32, i32* %7
%1115 = load i32, i32* %5
%1116 = load i32, i32* %6
%1117 = mul nsw i32 %1115, %1116
%1118 = sub nsw i32 %1114, %1117
store i32 %1118, i32* %7
br label %1119
1119: ; preds = %1102, %1090, %1078, %1066
%1120 = load i32*, i32** %11
%1121 = load i32, i32* %3
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds i32, i32* %1120, i64 %1122
%1124 = load i32, i32* %1123
%1125 = load i32*, i32** %11
%1126 = load i32, i32* %4
%1127 = sext i32 %1126 to i64
%1128 = getelementptr inbounds i32, i32* %1125, i64 %1127
%1129 = load i32, i32* %1128
%1130 = icmp sgt i32 %1124, %1129
br i1 %1130, label %1131, label %1160
1131: ; preds = %1119
%1132 = load i32*, i32** %12
%1133 = load i32, i32* %4
%1134 = sext i32 %1133 to i64
%1135 = getelementptr inbounds i32, i32* %1132, i64 %1134
%1136 = load i32, i32* %1135
%1137 = load i32*, i32** %12
%1138 = load i32, i32* %3
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds i32, i32* %1137, i64 %1139
%1141 = load i32, i32* %1140
%1142 = icmp sgt i32 %1136, %1141
br i1 %1142, label %1143, label %1160
1143: ; preds = %1131
%1144 = load i32*, i32** %12
%1145 = load i32, i32* %3
%1146 = sext i32 %1145 to i64
%1147 = getelementptr inbounds i32, i32* %1144, i64 %1146
%1148 = load i32, i32* %1147
%1149 = load i32*, i32** %11
%1150 = load i32, i32* %3
%1151 = sext i32 %1150 to i64
%1152 = getelementptr inbounds i32, i32* %1149, i64 %1151
%1153 = load i32, i32* %1152
%1154 = sub nsw i32 %1148, %1153
store i32 %1154, i32* %6
%1155 = load i32, i32* %7
%1156 = load i32, i32* %5
%1157 = load i32, i32* %6
%1158 = mul nsw i32 %1156, %1157
%1159 = sub nsw i32 %1155, %1158
store i32 %1159, i32* %7
br label %1160
1160: ; preds = %1143, %1131, %1119
br label %1161
1161: ; preds = %1160, %990, %978, %966
br label %1162
1162: ; preds = %1161
%1163 = load i32, i32* %4
%1164 = add nsw i32 %1163, 1
store i32 %1164, i32* %4
br label %207
1165: ; preds = %207
br label %1166
1166: ; preds = %1165
%1167 = load i32, i32* %3
%1168 = add nsw i32 %1167, 1
store i32 %1168, i32* %3
br label %199
1169: ; preds = %199
%1170 = load i32, i32* %7
store i32 %1170, i32* %1
br label %1171
1171: ; preds = %1169, %162, %126, %20
%1172 = load i32, i32* %1
ret i32 %1172
}

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