#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*/ free(char *);
char *malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int /*<<< orphan*/ sleep(int);
int main(int argc, char *argv[]) {
  int i;
  int a = 447;
  int b = a * a * a * 2 - 1;
  char *c1, *c2, *c3;
  c1 = malloc(sizeof(char) * b);
  c2 = malloc(sizeof(char) * b);
  c3 = malloc(sizeof(char) * b);
  for (i = 0; i < b; i++) {
    c1[i] = 10;
    c2[i] = 20;
    c3[i] = 30;
  }
  if (i == b) {
    printf("c1,c2,c3 arrays mem alloc 3 x %d bytes (3 x %dMB) done!\n", b,
           (b + 1) / 1024 / 1024);
    printf("so you get cube 812 x 812 x 812 witch cells 8-bits each wide\n\n");
  }
  sleep(5);
  int cube = 810;
  int za1 = 1 - 1;
  int za2 = 270 - 1;
  int za3 = 271 - 1;
  int za4 = 540 - 1;
  int za5 = 541 - 1;
  int za6 = 810 - 1;
  int za7 = 811 - a;
  int x1 = -1;
  int y1 = -1;
  int z1 = -1;
  int x2 = -1;
  int y2 = -1;
  int z2 = -1;
  int x3 = -1;
  int y3 = -1;
  int z3 = -1;
  int x4 = -1;
  int y4 = -1;
  int z4 = -1;
  int x5 = -1;
  int y5 = -1;
  int z5 = -1;
  int x6 = -1;
  int y6 = -1;
  int z6 = -1;
  int x7 = -1;
  int y7 = -1;
  int z7 = -1;
  int x8 = -1;
  int y8 = -1;
  int z8 = -1;
  int p1 = 0;
  int p2 = 0;
  int p3 = 0;
  int p4 = 0;
  int p5 = 0;
  int p6 = 0;
  int p7 = 0;
  int p8 = 0;
  int val1 = -1;
  int val2 = -1;
  int val3 = -1;
  int val4 = -1;
  int val5 = -1;
  int val6 = -1;
  int val7 = -1;
  int val8 = -1;
  int choice = 0;
  int quit = 0;
  while (quit == 0) {
    printf("\e[1;1H\e[2J");
    if (x1 < 0 || x1 > cube || y1 < 0 || y1 > cube || z1 < 0 || z1 > cube) {
      printf("P1: niekreślono wpółrzędnych\n");
      p1 = 0;
    } else {
      printf("P1: x1=%d\ty1=%d\tz1=%d\n", x1, y1, z1);
      p1 = 1;
    }
    if (x2 < 0 || x2 > cube || y2 < 0 || y2 > cube || z2 < 0 || z2 > cube) {
      printf("P2: niekreślono wpółrzędnych\n");
      p2 = 0;
    } else {
      printf("P2: x2=%d\ty2=%d\tz2=%d\n", x2, y2, z2);
      p2 = 1;
    }
    if (x3 < 0 || x3 > cube || y3 < 0 || y3 > cube || z3 < 0 || z3 > cube) {
      printf("P3: niekreślono wpółrzędnych\n");
      p3 = 0;
    } else {
      printf("P3: x3=%d\ty3=%d\tz3=%d\n", x3, y3, z3);
      p3 = 1;
    }
    if (x4 < 0 || x4 > cube || y4 < 0 || y4 > cube || z4 < 0 || z4 > cube) {
      printf("P4: niekreślono wpółrzędnych\n");
      p4 = 0;
    } else {
      printf("P4: x4=%d\ty4=%d\tz4=%d\n", x4, y4, z4);
      p4 = 1;
    }
    if (x5 < 0 || x5 > cube || y5 < 0 || y5 > cube || z5 < 0 || z5 > cube) {
      printf("P5: niekreślono wpółrzędnych\n");
      p5 = 0;
    } else {
      printf("P5: x5=%d\ty5=%d\tz5=%d\n", x5, y5, z5);
      p5 = 1;
    }
    if (x6 < 0 || x6 > cube || y6 < 0 || y6 > cube || z6 < 0 || z6 > cube) {
      printf("P6: niekreślono wpółrzędnych\n");
      p6 = 0;
    } else {
      printf("P6: x6=%d\ty6=%d\tz6=%d\n", x6, y6, z6);
      p6 = 1;
    }
    if (x7 < 0 || x7 > cube || y7 < 0 || y7 > cube || z7 < 0 || z4 > cube) {
      printf("P7: niekreślono wpółrzędnych\n");
      p7 = 0;
    } else {
      printf("P7: x7=%d\ty7=%d\tz7=%d\n", x7, y7, z7);
      p7 = 1;
    }
    if (x8 < 0 || x8 > cube || y8 < 0 || y8 > cube || z8 < 0 || z8 > cube) {
      printf("P8: niekreślono wpółrzędnych\n");
      p8 = 0;
    } else {
      printf("P8: x8=%d\ty8=%d\tz8=%d\n", x8, y8, z8);
      p8 = 1;
    }
    if (0 <= val1 && val1 <= 255 && 0 <= val2 && val2 <= 255 && 0 <= val3 &&
        val3 <= 255 && 0 <= val4 && val4 <= 255 && 0 <= val5 && val5 <= 255 &&
        0 <= val6 && val6 <= 255 && 0 <= val7 && val7 <= 255 && 0 <= val8 &&
        val8 <= 255) {
      printf("podane wartości: val1=%d val2=%d val3=%d val4=%d \n", val1, val2,
             val3, val4);
      printf("podane wartości: val5=%d val6=%d val7=%d val8=%d \n", val5, val6,
             val7, val8);
    }
    printf("Menu:\n");
    printf("1. podaj współrzędne wierzchołka P1 sześcianu - dolna ściana\n");
    printf("2. podaj współrzędne wierzchołka P2 sześcianu - dolna ściana\n");
    printf("3. podaj współrzędne wierzchołka P3 sześcianu - dolna ściana\n");
    printf("4. podaj współrzędne wierzchołka P4 sześcianu - dolna ściana\n");
    printf("5. podaj współrzędne wierzchołka P5 sześcianu - górna ściana\n");
    printf("6. podaj współrzędne wierzchołka P6 sześcianu - górna ściana\n");
    printf("7. podaj współrzędne wierzchołka P7 sześcianu - górna ściana\n");
    printf("8. podaj współrzędne wierzchołka P8 sześcianu - górna ściana\n");
    printf("9. czytaj określone punkty\n");
    printf("10. podaj 8 wartości z zakresu 0-255\n");
    printf("11. zapisz wartości w podanych punktach\n");
    printf("0. koniec\n");
    scanf("%d", &choice);
    switch (choice) {
    case 1:
      printf("x1=");
      scanf(" %d", &x1);
      printf("y1=");
      scanf(" %d", &y1);
      printf("z1=");
      scanf(" %d", &z1);
      if (x1 < 0 || x1 > cube || y1 < 0 || y1 > cube || z1 < 0 || z1 > cube) {
        printf("P1: poza zakresem!\n");
        x1 = -1;
        y1 = -1;
        z1 = -1;
        break;
      }
      break;
    case 2:
      printf("x2=");
      scanf(" %d", &x2);
      printf("y2=");
      scanf(" %d", &y2);
      printf("z2=");
      scanf(" %d", &z2);
      if (x2 < 0 || x2 > cube || y2 < 0 || y2 > cube || z2 < 0 || z2 > cube) {
        printf("P2: poza zakresem!\n");
        x2 = -1;
        y2 = -1;
        z2 = -1;
        break;
      }
      break;
    case 3:
      printf("x3=");
      scanf(" %d", &x3);
      printf("y3=");
      scanf(" %d", &y3);
      printf("z3=");
      scanf(" %d", &z3);
      if (x3 < 0 || x3 > cube || y3 < 0 || y3 > cube || z3 < 0 || z3 > cube) {
        printf("P3: poza zakresem!\n");
        x3 = -1;
        y3 = -1;
        z3 = -1;
        break;
      }
      break;
    case 4:
      printf("x4=");
      scanf(" %d", &x4);
      printf("y4=");
      scanf(" %d", &y4);
      printf("z4=");
      scanf(" %d", &z4);
      if (x4 < 0 || x4 > cube || y4 < 0 || y4 > cube || z4 < 0 || z4 > cube) {
        printf("P4: poza zakresem!\n");
        x4 = -1;
        y4 = -1;
        z4 = -1;
        break;
      }
      break;
    case 5:
      printf("x5=");
      scanf(" %d", &x5);
      printf("y5=");
      scanf(" %d", &y5);
      printf("z5=");
      scanf(" %d", &z5);
      if (x5 < 0 || x5 > cube || y5 < 0 || y5 > cube || z5 < 0 || z5 > cube) {
        printf("P5: poza zakresem!\n");
        x5 = -1;
        y5 = -1;
        z5 = -1;
        break;
      }
      break;
    case 6:
      printf("x6=");
      scanf(" %d", &x6);
      printf("y6=");
      scanf(" %d", &y6);
      printf("z6=");
      scanf(" %d", &z6);
      if (x6 < 0 || x6 > cube || y6 < 0 || y6 > cube || z6 < 0 || z4 > cube) {
        printf("P6: poza zakresem!\n");
        x6 = -1;
        y6 = -1;
        z6 = -1;
        break;
      }
      break;
    case 7:
      printf("x7=");
      scanf(" %d", &x7);
      printf("y7=");
      scanf(" %d", &y7);
      printf("z7=");
      scanf(" %d", &z7);
      if (x7 < 0 || x7 > cube || y7 < 0 || y7 > cube || z7 < 0 || z7 > cube) {
        printf("P7: poza zakresem!\n");
        x7 = -1;
        y7 = -1;
        z7 = -1;
        break;
      }
      break;
    case 8:
      printf("x8=");
      scanf(" %d", &x8);
      printf("y8=");
      scanf(" %d", &y8);
      printf("z8=");
      scanf(" %d", &z8);
      if (x8 < 0 || x8 > cube || y8 < 0 || y8 > cube || z8 < 0 || z8 > cube) {
        printf("P8: poza zakresem!\n");
        x8 = -1;
        y8 = -1;
        z8 = -1;
        break;
      }
      break;
    case 9:
      if (p1) {
        if (z1 <= za2)
          printf("<c1> P1(%d,%d,%d)=%d\n", x1, y1, z1, c1[x1 * y1 * z1]);
        if (z1 >= za3 && z1 <= za4)
          printf("<c2> P1(%d,%d,%d)=%d\n", x1, y1, z1,
                 c2[x1 * y1 * (z1 - za3)]);
        if (z1 >= za5 && z1 <= za6)
          printf("<c3> P1(%d,%d,%d)=%d\n", x1, y1, z1,
                 c3[x1 * y1 * (z1 - za5)]);
      }
      if (p2) {
        if (z2 <= za2)
          printf("<c1> P2(%d,%d,%d)=%d\n", x2, y2, z2, c1[x2 * y2 * z2]);
        if (z2 >= za3 && z2 <= za4)
          printf("<c2> P2(%d,%d,%d)=%d\n", x2, y2, z2,
                 c2[x2 * y2 * (z2 - za3)]);
        if (z2 >= za5 && z2 <= za6)
          printf("<c3> P2(%d,%d,%d)=%d\n", x2, y2, z2,
                 c3[x2 * y2 * (z2 - za5)]);
      }
      if (p3) {
        if (z3 <= za2)
          printf("<c1> P3(%d,%d,%d)=%d\n", x3, y3, z3, c1[x3 * y3 * z3]);
        if (z3 >= za3 && z3 <= za4)
          printf("<c2> P3(%d,%d,%d)=%d\n", x3, y3, z3,
                 c2[x3 * y3 * (z3 - za3)]);
        if (z3 >= za5 && z3 <= za6)
          printf("<c3> P3(%d,%d,%d)=%d\n", x3, y3, z3,
                 c3[x3 * y3 * (z3 - za5)]);
      }
      if (p4) {
        if (z4 <= za2)
          printf("<c1> P4(%d,%d,%d)=%d\n", x4, y4, z4, c1[x4 * y4 * z4]);
        if (z4 >= za3 && z4 <= za4)
          printf("<c2> P4(%d,%d,%d)=%d\n", x4, y4, z4,
                 c2[x4 * y4 * (z4 - za3)]);
        if (z4 >= za5 && z4 <= za6)
          printf("<c3> P4(%d,%d,%d)=%d\n", x4, y4, z4,
                 c3[x4 * y4 * (z4 - za5)]);
      }
      if (p5) {
        if (z5 <= za2)
          printf("<c1> P5(%d,%d,%d)=%d\n", x5, y5, z5, c1[x5 * y5 * z5]);
        if (z5 >= za3 && z5 <= za4)
          printf("<c2> P5(%d,%d,%d)=%d\n", x5, y5, z5,
                 c2[x5 * y5 * (z5 - za3)]);
        if (z5 >= za5 && z5 <= za6)
          printf("<c3> P5(%d,%d,%d)=%d\n", x5, y5, z5,
                 c3[x5 * y5 * (z5 - za5)]);
      }
      if (p6) {
        if (z6 <= za2)
          printf("<c1> P6(%d,%d,%d)=%d\n", x6, y6, z6, c1[x6 * y6 * z6]);
        if (z6 >= za3 && z6 <= za4)
          printf("<c2> P6(%d,%d,%d)=%d\n", x6, y6, z6,
                 c2[x6 * y6 * (z6 - za3)]);
        if (z6 >= za5 && z6 <= za6)
          printf("<c3> P6(%d,%d,%d)=%d\n", x6, y6, z6,
                 c3[x6 * y6 * (z6 - za5)]);
      }
      if (p7) {
        if (z7 <= za2)
          printf("<c1> P7(%d,%d,%d)=%d\n", x7, y7, z7, c1[x7 * y7 * z7]);
        if (z7 >= za3 && z7 <= za4)
          printf("<c2> P7(%d,%d,%d)=%d\n", x7, y7, z7,
                 c2[x7 * y7 * (z7 - 620)]);
        if (z7 >= za5 && z7 <= za6)
          printf("<c3> P7(%d,%d,%d)=%d\n", x7, y7, z7,
                 c3[x7 * y7 * (z7 - 1240)]);
      }
      if (p8) {
        if (z8 <= za2)
          printf("<c1> P8(%d,%d,%d)=%d\n", x8, y8, z8, c1[x8 * y8 * z8]);
        if (z8 >= za3 && z8 <= za4)
          printf("<c2> P8(%d,%d,%d)=%d\n", x8, y8, z8,
                 c2[x8 * y8 * (z8 - za3)]);
        if (z8 >= za5 && z8 <= za6)
          printf("<c3> P8(%d,%d,%d)=%d\n", x8, y8, z8,
                 c3[x8 * y8 * (z8 - za5)]);
      }
      printf("hit enter\n");
      scanf("%s", &i);
      break;
    case 10:
      printf("podaj 8 wartości z przedziału <0,255>\n");
      while (1) {
        printf("\nwartość val1 dla P1:\n");
        scanf(" %d", &val1);
        printf("\nwartość val2 dla P2:\n");
        scanf(" %d", &val2);
        printf("\nwartość val3 dla P3:\n");
        scanf(" %d", &val3);
        printf("\nwartość val4 dla P4:\n");
        scanf(" %d", &val4);
        printf("\nwartość val5 dla P5:\n");
        scanf(" %d", &val5);
        printf("\nwartość val6 dla P6:\n");
        scanf(" %d", &val6);
        printf("\nwartość val7 dla P7:\n");
        scanf(" %d", &val7);
        printf("\nwartość val8 dla P8:\n");
        scanf(" %d", &val8);
        if (0 <= val1 && val1 <= 255 && 0 <= val2 && val2 <= 255 && 0 <= val3 &&
            val3 <= 255 && 0 <= val4 && val4 <= 255 && 0 <= val5 &&
            val5 <= 255 && 0 <= val6 && val6 <= 255 && 0 <= val7 &&
            val7 <= 255 && 0 <= val8 && val8 <= 255) {
          printf("podane wartości: val1=%d val2=%d val3=%d val4=%d \n", val1,
                 val2, val3, val4);
          printf("podane wartości: val5=%d val6=%d val7=%d val8=%d \n", val5,
                 val6, val7, val8);
          break;
        } else {
          val1 = -1;
          val2 = -1;
          val3 = -1;
          val4 = -1;
          val5 = -1;
          val6 = -1;
          val7 = -1;
          val8 = -1;
        }
      }
      break;
    case 11:
      if (p1) {
        if (z1 <= za2)
          c1[x1 * y1 * z1] = val1;
        if (z1 >= za3 && z1 <= za4)
          c2[x1 * y1 * (z1 - za3)] = val1;
        if (z1 >= za5 && z1 <= za6)
          c3[x1 * y1 * (z1 - za5)] = val1;
      }
      if (p2) {
        if (z2 <= za2)
          c1[x2 * y2 * z2] = val2;
        if (z2 >= za3 && z2 <= za4)
          c2[x2 * y2 * (z2 - za3)] = val2;
        if (z2 >= za5 && z2 <= za6)
          c3[x2 * y2 * (z2 - za5)] = val2;
      }
      if (p3) {
        if (z3 <= za2)
          c1[x3 * y3 * z3] = val3;
        if (z3 >= za3 && z3 <= za4)
          c2[x3 * y3 * (z3 - za3)] = val3;
        if (z3 >= za5 && z3 <= za6)
          c3[x3 * y3 * (z3 - za5)] = val3;
      }
      if (p4) {
        if (z4 <= za2)
          c1[x4 * y4 * z4] = val4;
        if (z4 >= za3 && z4 <= za4)
          c2[x4 * y4 * (z4 - za3)] = val4;
        if (z4 >= za5 && z4 <= za6)
          c3[x4 * y4 * (z4 - za5)] = val4;
      }
      if (p5) {
        if (z5 <= za2)
          c1[x5 * y5 * z5] = val5;
        if (z5 >= za3 && z5 <= za4)
          c2[x5 * y5 * (z5 - za3)] = val5;
        if (z5 >= za5 && z5 <= za6)
          c3[x5 * y5 * (z5 - za5)] = val5;
      }
      if (p6) {
        if (z6 <= za2)
          c1[x6 * y6 * z6] = val6;
        if (z6 >= za3 && z6 <= za4)
          c2[x6 * y6 * (z6 - 620)] = val6;
        if (z6 >= za5 && z6 <= za6)
          c3[x6 * y6 * (z6 - 1240)] = val6;
      }
      if (p7) {
        if (z7 <= za2)
          c1[x7 * y7 * z7] = val7;
        if (z7 >= za3 && z7 <= za4)
          c2[x7 * y7 * (z7 - za3)] = val7;
        if (z7 >= za5 && z7 <= za6)
          c3[x7 * y7 * (z7 - za5)] = val7;
      }
      if (p8) {
        if (z8 <= za2)
          c1[x8 * y8 * z8] = val8;
        if (z8 >= za3 && z8 <= za4)
          c2[x8 * y8 * (z8 - za3)] = val8;
        if (z8 >= za5 && z8 <= za6)
          c3[x8 * y8 * (z8 - za5)] = val8;
      }
      printf("hit enter\n");
      scanf("%s", &i);
      break;
    case 0:
      free(c1);
      free(c2);
      free(c3);
      printf("mem cleared\n");
      return 0;
    default:
      continue;
    }
  }
  printf("ctrl+c to quit\n");
  while (1) {
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x1bf,-0x18(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x18(%rbp),%eax
imul   -0x18(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1202 <main+0xb2>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0xa,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x14,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x1e,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11c4 <main+0x74>
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1245 <main+0xf5>
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    $0x400,%ecx
cltd
idiv   %ecx
mov    $0x400,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0x2e00(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2e2b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x5,%edi
call   1070 <sleep@plt>
movl   $0x32a,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x10d,-0x44(%rbp)
movl   $0x10e,-0x48(%rbp)
movl   $0x21b,-0x4c(%rbp)
movl   $0x21c,-0x50(%rbp)
movl   $0x329,-0x54(%rbp)
mov    $0x32b,%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0xffffffff,-0x5c(%rbp)
movl   $0xffffffff,-0x60(%rbp)
movl   $0xffffffff,-0x64(%rbp)
movl   $0xffffffff,-0x68(%rbp)
movl   $0xffffffff,-0x6c(%rbp)
movl   $0xffffffff,-0x70(%rbp)
movl   $0xffffffff,-0x74(%rbp)
movl   $0xffffffff,-0x78(%rbp)
movl   $0xffffffff,-0x7c(%rbp)
movl   $0xffffffff,-0x80(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
movl   $0xffffffff,-0x8c(%rbp)
ff ff ff
movl   $0xffffffff,-0x90(%rbp)
ff ff ff
movl   $0xffffffff,-0x94(%rbp)
movl   $0xffffffff,-0x98(%rbp)
ff ff ff
movl   $0xffffffff,-0x9c(%rbp)
ff ff ff
movl   $0xffffffff,-0xa0(%rbp)
ff ff ff
movl   $0xffffffff,-0xa4(%rbp)
ff ff ff
movl   $0xffffffff,-0xa8(%rbp)
ff ff ff
movl   $0xffffffff,-0xac(%rbp)
ff ff ff
movl   $0xffffffff,-0xb0(%rbp)
ff ff ff
movl   $0xffffffff,-0xb4(%rbp)
ff ff ff
movl   $0xffffffff,-0xb8(%rbp)
ff ff ff
movl   $0x0,-0xbc(%rbp)
movl   $0x0,-0xc0(%rbp)
movl   $0x0,-0xc4(%rbp)
movl   $0x0,-0xc8(%rbp)
movl   $0x0,-0xcc(%rbp)
movl   $0x0,-0xd0(%rbp)
movl   $0x0,-0xd4(%rbp)
movl   $0x0,-0xd8(%rbp)
movl   $0xffffffff,-0xdc(%rbp)
ff ff ff
movl   $0xffffffff,-0xe0(%rbp)
ff ff ff
movl   $0xffffffff,-0xe4(%rbp)
ff ff ff
movl   $0xffffffff,-0xe8(%rbp)
ff ff ff
movl   $0xffffffff,-0xec(%rbp)
ff ff ff
movl   $0xffffffff,-0xf0(%rbp)
ff ff ff
movl   $0xffffffff,-0xf4(%rbp)
ff ff ff
movl   $0xffffffff,-0xf8(%rbp)
ff ff ff
movl   $0x0,-0xfc(%rbp)
movl   $0x0,-0x100(%rbp)
cmpl   $0x0,-0x100(%rbp)
jne    3410 <main+0x22c0>
lea    0x2c83(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x5c(%rbp)
jl     146e <main+0x31e>
mov    -0x5c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     146e <main+0x31e>
cmpl   $0x0,-0x60(%rbp)
jl     146e <main+0x31e>
mov    -0x60(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     146e <main+0x31e>
cmpl   $0x0,-0x64(%rbp)
jl     146e <main+0x31e>
mov    -0x64(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    148b <main+0x33b>
lea    0x2c3e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xbc(%rbp)
jmp    14ac <main+0x35c>
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x64(%rbp),%ecx
lea    0x2c3a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xbc(%rbp)
cmpl   $0x0,-0x68(%rbp)
jl     14ee <main+0x39e>
mov    -0x68(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     14ee <main+0x39e>
cmpl   $0x0,-0x6c(%rbp)
jl     14ee <main+0x39e>
mov    -0x6c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     14ee <main+0x39e>
cmpl   $0x0,-0x70(%rbp)
jl     14ee <main+0x39e>
mov    -0x70(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    150b <main+0x3bb>
lea    0x2bf7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc0(%rbp)
jmp    152c <main+0x3dc>
mov    -0x68(%rbp),%esi
mov    -0x6c(%rbp),%edx
mov    -0x70(%rbp),%ecx
lea    0x2bf3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xc0(%rbp)
cmpl   $0x0,-0x74(%rbp)
jl     156e <main+0x41e>
mov    -0x74(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     156e <main+0x41e>
cmpl   $0x0,-0x78(%rbp)
jl     156e <main+0x41e>
mov    -0x78(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     156e <main+0x41e>
cmpl   $0x0,-0x7c(%rbp)
jl     156e <main+0x41e>
mov    -0x7c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    158b <main+0x43b>
lea    0x2bb0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc4(%rbp)
jmp    15ac <main+0x45c>
mov    -0x74(%rbp),%esi
mov    -0x78(%rbp),%edx
mov    -0x7c(%rbp),%ecx
lea    0x2bac(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xc4(%rbp)
cmpl   $0x0,-0x80(%rbp)
jl     15fa <main+0x4aa>
mov    -0x80(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     15fa <main+0x4aa>
cmpl   $0x0,-0x84(%rbp)
jl     15fa <main+0x4aa>
mov    -0x84(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     15fa <main+0x4aa>
cmpl   $0x0,-0x88(%rbp)
jl     15fa <main+0x4aa>
mov    -0x88(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1617 <main+0x4c7>
lea    0x2b5d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc8(%rbp)
jmp    163e <main+0x4ee>
mov    -0x80(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
lea    0x2b53(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xc8(%rbp)
cmpl   $0x0,-0x8c(%rbp)
jl     1692 <main+0x542>
mov    -0x8c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1692 <main+0x542>
cmpl   $0x0,-0x90(%rbp)
jl     1692 <main+0x542>
mov    -0x90(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1692 <main+0x542>
cmpl   $0x0,-0x94(%rbp)
jl     1692 <main+0x542>
mov    -0x94(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    16af <main+0x55f>
lea    0x2afe(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xcc(%rbp)
jmp    16d9 <main+0x589>
mov    -0x8c(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    -0x94(%rbp),%ecx
lea    0x2af1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xcc(%rbp)
cmpl   $0x0,-0x98(%rbp)
jl     172d <main+0x5dd>
mov    -0x98(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     172d <main+0x5dd>
cmpl   $0x0,-0x9c(%rbp)
jl     172d <main+0x5dd>
mov    -0x9c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     172d <main+0x5dd>
cmpl   $0x0,-0xa0(%rbp)
jl     172d <main+0x5dd>
mov    -0xa0(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    174a <main+0x5fa>
lea    0x2a9c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xd0(%rbp)
jmp    1774 <main+0x624>
mov    -0x98(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
lea    0x2a8f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xd0(%rbp)
cmpl   $0x0,-0xa4(%rbp)
jl     17c8 <main+0x678>
mov    -0xa4(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     17c8 <main+0x678>
cmpl   $0x0,-0xa8(%rbp)
jl     17c8 <main+0x678>
mov    -0xa8(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     17c8 <main+0x678>
cmpl   $0x0,-0xac(%rbp)
jl     17c8 <main+0x678>
mov    -0x88(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    17e5 <main+0x695>
lea    0x2a3a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xd4(%rbp)
jmp    180f <main+0x6bf>
mov    -0xa4(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    -0xac(%rbp),%ecx
lea    0x2a2d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xd4(%rbp)
cmpl   $0x0,-0xb0(%rbp)
jl     1863 <main+0x713>
mov    -0xb0(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1863 <main+0x713>
cmpl   $0x0,-0xb4(%rbp)
jl     1863 <main+0x713>
mov    -0xb4(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1863 <main+0x713>
cmpl   $0x0,-0xb8(%rbp)
jl     1863 <main+0x713>
mov    -0xb8(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1880 <main+0x730>
lea    0x29d8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xd8(%rbp)
jmp    18aa <main+0x75a>
mov    -0xb0(%rbp),%esi
mov    -0xb4(%rbp),%edx
mov    -0xb8(%rbp),%ecx
lea    0x29cb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xd8(%rbp)
xor    %eax,%eax
cmp    -0xdc(%rbp),%eax
jg     19e8 <main+0x898>
cmpl   $0xff,-0xdc(%rbp)
jg     19e8 <main+0x898>
xor    %eax,%eax
cmp    -0xe0(%rbp),%eax
jg     19e8 <main+0x898>
cmpl   $0xff,-0xe0(%rbp)
jg     19e8 <main+0x898>
xor    %eax,%eax
cmp    -0xe4(%rbp),%eax
jg     19e8 <main+0x898>
cmpl   $0xff,-0xe4(%rbp)
jg     19e8 <main+0x898>
xor    %eax,%eax
cmp    -0xe8(%rbp),%eax
jg     19e8 <main+0x898>
cmpl   $0xff,-0xe8(%rbp)
jg     19e8 <main+0x898>
xor    %eax,%eax
cmp    -0xec(%rbp),%eax
jg     19e8 <main+0x898>
cmpl   $0xff,-0xec(%rbp)
jg     19e8 <main+0x898>
xor    %eax,%eax
cmp    -0xf0(%rbp),%eax
jg     19e8 <main+0x898>
cmpl   $0xff,-0xf0(%rbp)
jg     19e8 <main+0x898>
xor    %eax,%eax
cmp    -0xf4(%rbp),%eax
jg     19e8 <main+0x898>
cmpl   $0xff,-0xf4(%rbp)
jg     19e8 <main+0x898>
xor    %eax,%eax
cmp    -0xf8(%rbp),%eax
jg     19e8 <main+0x898>
cmpl   $0xff,-0xf8(%rbp)
jg     19e8 <main+0x898>
mov    -0xdc(%rbp),%esi
mov    -0xe0(%rbp),%edx
mov    -0xe4(%rbp),%ecx
mov    -0xe8(%rbp),%r8d
lea    0x28c1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xec(%rbp),%esi
mov    -0xf0(%rbp),%edx
mov    -0xf4(%rbp),%ecx
mov    -0xf8(%rbp),%r8d
lea    0x28ce(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x28f4(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x109(%rbp)
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x28e1(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2913(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2945(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2977(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x29a9(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x29dc(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2a0f(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2a42(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2a75(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2a80(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2a95(%rip),%rdi
call   1040 <printf@plt>
mov    -0x109(%rbp),%al
lea    0x2aad(%rip),%rdi
call   1040 <printf@plt>
lea    0x2ab1(%rip),%rdi
lea    -0xfc(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xfc(%rbp),%eax
mov    %rax,-0x108(%rbp)
sub    $0xb,%rax
ja     3406 <main+0x22b6>
mov    -0x108(%rbp),%rax
lea    0x24f4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x2a6b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2a61(%rip),%rdi
lea    -0x5c(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x2a55(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2a43(%rip),%rdi
lea    -0x60(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x2a3b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2a25(%rip),%rdi
lea    -0x64(%rbp),%rsi
call   1060 <scanf@plt>
cmpl   $0x0,-0x5c(%rbp)
jl     1bb1 <main+0xa61>
mov    -0x5c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1bb1 <main+0xa61>
cmpl   $0x0,-0x60(%rbp)
jl     1bb1 <main+0xa61>
mov    -0x60(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1bb1 <main+0xa61>
cmpl   $0x0,-0x64(%rbp)
jl     1bb1 <main+0xa61>
mov    -0x64(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1bd9 <main+0xa89>
lea    0x29df(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x5c(%rbp)
movl   $0xffffffff,-0x60(%rbp)
movl   $0xffffffff,-0x64(%rbp)
jmp    340b <main+0x22bb>
jmp    340b <main+0x22bb>
lea    0x29c6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2998(%rip),%rdi
lea    -0x68(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x29ac(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x297a(%rip),%rdi
lea    -0x6c(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x2992(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x295c(%rip),%rdi
lea    -0x70(%rbp),%rsi
call   1060 <scanf@plt>
cmpl   $0x0,-0x68(%rbp)
jl     1c7a <main+0xb2a>
mov    -0x68(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1c7a <main+0xb2a>
cmpl   $0x0,-0x6c(%rbp)
jl     1c7a <main+0xb2a>
mov    -0x6c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1c7a <main+0xb2a>
cmpl   $0x0,-0x70(%rbp)
jl     1c7a <main+0xb2a>
mov    -0x70(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1ca2 <main+0xb52>
lea    0x2936(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x68(%rbp)
movl   $0xffffffff,-0x6c(%rbp)
movl   $0xffffffff,-0x70(%rbp)
jmp    340b <main+0x22bb>
jmp    340b <main+0x22bb>
lea    0x291d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x28cf(%rip),%rdi
lea    -0x74(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x2903(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x28b1(%rip),%rdi
lea    -0x78(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x28e9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2893(%rip),%rdi
lea    -0x7c(%rbp),%rsi
call   1060 <scanf@plt>
cmpl   $0x0,-0x74(%rbp)
jl     1d43 <main+0xbf3>
mov    -0x74(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1d43 <main+0xbf3>
cmpl   $0x0,-0x78(%rbp)
jl     1d43 <main+0xbf3>
mov    -0x78(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1d43 <main+0xbf3>
cmpl   $0x0,-0x7c(%rbp)
jl     1d43 <main+0xbf3>
mov    -0x7c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1d6b <main+0xc1b>
lea    0x288d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x74(%rbp)
movl   $0xffffffff,-0x78(%rbp)
movl   $0xffffffff,-0x7c(%rbp)
jmp    340b <main+0x22bb>
jmp    340b <main+0x22bb>
lea    0x2874(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2806(%rip),%rdi
lea    -0x80(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x285a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x27e8(%rip),%rdi
lea    -0x84(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x283d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x27c7(%rip),%rdi
lea    -0x88(%rbp),%rsi
call   1060 <scanf@plt>
cmpl   $0x0,-0x80(%rbp)
jl     1e1e <main+0xcce>
mov    -0x80(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1e1e <main+0xcce>
cmpl   $0x0,-0x84(%rbp)
jl     1e1e <main+0xcce>
mov    -0x84(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1e1e <main+0xcce>
cmpl   $0x0,-0x88(%rbp)
jl     1e1e <main+0xcce>
mov    -0x88(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1e4c <main+0xcfc>
lea    0x27d2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x80(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
jmp    340b <main+0x22bb>
jmp    340b <main+0x22bb>
lea    0x27b3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2725(%rip),%rdi
lea    -0x8c(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x2796(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2704(%rip),%rdi
lea    -0x90(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x2779(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x26e3(%rip),%rdi
lea    -0x94(%rbp),%rsi
call   1060 <scanf@plt>
cmpl   $0x0,-0x8c(%rbp)
jl     1f08 <main+0xdb8>
mov    -0x8c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1f08 <main+0xdb8>
cmpl   $0x0,-0x90(%rbp)
jl     1f08 <main+0xdb8>
mov    -0x90(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1f08 <main+0xdb8>
cmpl   $0x0,-0x94(%rbp)
jl     1f08 <main+0xdb8>
mov    -0x94(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1f39 <main+0xde9>
lea    0x2708(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x8c(%rbp)
ff ff ff
movl   $0xffffffff,-0x90(%rbp)
ff ff ff
movl   $0xffffffff,-0x94(%rbp)
ff ff ff
jmp    340b <main+0x22bb>
jmp    340b <main+0x22bb>
lea    0x26e6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2638(%rip),%rdi
lea    -0x98(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x26c9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2617(%rip),%rdi
lea    -0x9c(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x26ac(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x25f6(%rip),%rdi
lea    -0xa0(%rbp),%rsi
call   1060 <scanf@plt>
cmpl   $0x0,-0x98(%rbp)
jl     1ff5 <main+0xea5>
mov    -0x98(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1ff5 <main+0xea5>
cmpl   $0x0,-0x9c(%rbp)
jl     1ff5 <main+0xea5>
mov    -0x9c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1ff5 <main+0xea5>
cmpl   $0x0,-0xa0(%rbp)
jl     1ff5 <main+0xea5>
mov    -0x88(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    2026 <main+0xed6>
lea    0x263b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x98(%rbp)
movl   $0xffffffff,-0x9c(%rbp)
ff ff ff
movl   $0xffffffff,-0xa0(%rbp)
ff ff ff
jmp    340b <main+0x22bb>
jmp    340b <main+0x22bb>
lea    0x2619(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x254b(%rip),%rdi
lea    -0xa4(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x25fc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x252a(%rip),%rdi
lea    -0xa8(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x25df(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x2509(%rip),%rdi
lea    -0xac(%rbp),%rsi
call   1060 <scanf@plt>
cmpl   $0x0,-0xa4(%rbp)
jl     20e2 <main+0xf92>
mov    -0xa4(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     20e2 <main+0xf92>
cmpl   $0x0,-0xa8(%rbp)
jl     20e2 <main+0xf92>
mov    -0xa8(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     20e2 <main+0xf92>
cmpl   $0x0,-0xac(%rbp)
jl     20e2 <main+0xf92>
mov    -0xac(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    2113 <main+0xfc3>
lea    0x256e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0xa4(%rbp)
ff ff ff
movl   $0xffffffff,-0xa8(%rbp)
ff ff ff
movl   $0xffffffff,-0xac(%rbp)
ff ff ff
jmp    340b <main+0x22bb>
jmp    340b <main+0x22bb>
lea    0x254c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x245e(%rip),%rdi
lea    -0xb0(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x252f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x243d(%rip),%rdi
lea    -0xb4(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x2512(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x241c(%rip),%rdi
lea    -0xb8(%rbp),%rsi
call   1060 <scanf@plt>
cmpl   $0x0,-0xb0(%rbp)
jl     21cf <main+0x107f>
mov    -0xb0(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     21cf <main+0x107f>
cmpl   $0x0,-0xb4(%rbp)
jl     21cf <main+0x107f>
mov    -0xb4(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     21cf <main+0x107f>
cmpl   $0x0,-0xb8(%rbp)
jl     21cf <main+0x107f>
mov    -0xb8(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    2200 <main+0x10b0>
lea    0x24a1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0xb0(%rbp)
ff ff ff
movl   $0xffffffff,-0xb4(%rbp)
ff ff ff
movl   $0xffffffff,-0xb8(%rbp)
ff ff ff
jmp    340b <main+0x22bb>
jmp    340b <main+0x22bb>
cmpl   $0x0,-0xbc(%rbp)
je     22ed <main+0x119d>
mov    -0x64(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     224c <main+0x10fc>
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x64(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%edi
imul   -0x60(%rbp),%edi
imul   -0x64(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x2446(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x64(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     229a <main+0x114a>
mov    -0x64(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     229a <main+0x114a>
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x64(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%edi
imul   -0x60(%rbp),%edi
mov    -0x64(%rbp),%r8d
sub    -0x48(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x240e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x64(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     22e8 <main+0x1198>
mov    -0x64(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     22e8 <main+0x1198>
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x64(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%edi
imul   -0x60(%rbp),%edi
mov    -0x64(%rbp),%r8d
sub    -0x50(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x23d6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    22ed <main+0x119d>
cmpl   $0x0,-0xc0(%rbp)
je     23d5 <main+0x1285>
mov    -0x70(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2334 <main+0x11e4>
mov    -0x68(%rbp),%esi
mov    -0x6c(%rbp),%edx
mov    -0x70(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%edi
imul   -0x6c(%rbp),%edi
imul   -0x70(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x23a0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x70(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     2382 <main+0x1232>
mov    -0x70(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2382 <main+0x1232>
mov    -0x68(%rbp),%esi
mov    -0x6c(%rbp),%edx
mov    -0x70(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%edi
imul   -0x6c(%rbp),%edi
mov    -0x70(%rbp),%r8d
sub    -0x48(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x2368(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x70(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     23d0 <main+0x1280>
mov    -0x70(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     23d0 <main+0x1280>
mov    -0x68(%rbp),%esi
mov    -0x6c(%rbp),%edx
mov    -0x70(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%edi
imul   -0x6c(%rbp),%edi
mov    -0x70(%rbp),%r8d
sub    -0x50(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x2330(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    23d5 <main+0x1285>
cmpl   $0x0,-0xc4(%rbp)
je     24bd <main+0x136d>
mov    -0x7c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     241c <main+0x12cc>
mov    -0x74(%rbp),%esi
mov    -0x78(%rbp),%edx
mov    -0x7c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    -0x74(%rbp),%edi
imul   -0x78(%rbp),%edi
imul   -0x7c(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x22fa(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x7c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     246a <main+0x131a>
mov    -0x7c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     246a <main+0x131a>
mov    -0x74(%rbp),%esi
mov    -0x78(%rbp),%edx
mov    -0x7c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%edi
imul   -0x78(%rbp),%edi
mov    -0x7c(%rbp),%r8d
sub    -0x48(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x22c2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x7c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     24b8 <main+0x1368>
mov    -0x7c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     24b8 <main+0x1368>
mov    -0x74(%rbp),%esi
mov    -0x78(%rbp),%edx
mov    -0x7c(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%edi
imul   -0x78(%rbp),%edi
mov    -0x7c(%rbp),%r8d
sub    -0x50(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x228a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    24bd <main+0x136d>
cmpl   $0x0,-0xc8(%rbp)
je     25d8 <main+0x1488>
mov    -0x88(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2513 <main+0x13c3>
mov    -0x80(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%edi
imul   -0x84(%rbp),%edi
imul   -0x88(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x2245(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x88(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     2573 <main+0x1423>
mov    -0x88(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2573 <main+0x1423>
mov    -0x80(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    -0x80(%rbp),%edi
imul   -0x84(%rbp),%edi
mov    -0x88(%rbp),%r8d
sub    -0x48(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x21fb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x88(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     25d3 <main+0x1483>
mov    -0x88(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     25d3 <main+0x1483>
mov    -0x80(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%edi
imul   -0x84(%rbp),%edi
mov    -0x88(%rbp),%r8d
sub    -0x50(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x21b1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    25d8 <main+0x1488>
cmpl   $0x0,-0xcc(%rbp)
je     2705 <main+0x15b5>
mov    -0x94(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2634 <main+0x14e4>
mov    -0x8c(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    -0x94(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    -0x8c(%rbp),%edi
imul   -0x90(%rbp),%edi
imul   -0x94(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x2166(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x94(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     269a <main+0x154a>
mov    -0x94(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     269a <main+0x154a>
mov    -0x8c(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    -0x94(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    -0x8c(%rbp),%edi
imul   -0x90(%rbp),%edi
mov    -0x94(%rbp),%r8d
sub    -0x48(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x2116(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x94(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     2700 <main+0x15b0>
mov    -0x94(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     2700 <main+0x15b0>
mov    -0x8c(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    -0x94(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    -0x8c(%rbp),%edi
imul   -0x90(%rbp),%edi
mov    -0x94(%rbp),%r8d
sub    -0x50(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x20c6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2705 <main+0x15b5>
cmpl   $0x0,-0xd0(%rbp)
je     2832 <main+0x16e2>
mov    -0xa0(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2761 <main+0x1611>
mov    -0x98(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    -0x98(%rbp),%edi
imul   -0x9c(%rbp),%edi
imul   -0xa0(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x207b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xa0(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     27c7 <main+0x1677>
mov    -0xa0(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     27c7 <main+0x1677>
mov    -0x98(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%edi
imul   -0x9c(%rbp),%edi
mov    -0xa0(%rbp),%r8d
sub    -0x48(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x202b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xa0(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     282d <main+0x16dd>
mov    -0xa0(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     282d <main+0x16dd>
mov    -0x98(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    -0x98(%rbp),%edi
imul   -0x9c(%rbp),%edi
mov    -0xa0(%rbp),%r8d
sub    -0x50(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x1fdb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2832 <main+0x16e2>
cmpl   $0x0,-0xd4(%rbp)
je     2965 <main+0x1815>
mov    -0xac(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     288e <main+0x173e>
mov    -0xa4(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    -0xac(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    -0xa4(%rbp),%edi
imul   -0xa8(%rbp),%edi
imul   -0xac(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x1f90(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xac(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     28f7 <main+0x17a7>
mov    -0xac(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     28f7 <main+0x17a7>
mov    -0xa4(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    -0xac(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    -0xa4(%rbp),%edi
imul   -0xa8(%rbp),%edi
mov    -0xac(%rbp),%r8d
sub    $0x26c,%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x1f3d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xac(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     2960 <main+0x1810>
mov    -0xac(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     2960 <main+0x1810>
mov    -0xa4(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    -0xac(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    -0xa4(%rbp),%edi
imul   -0xa8(%rbp),%edi
mov    -0xac(%rbp),%r8d
sub    $0x4d8,%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x1eea(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2965 <main+0x1815>
cmpl   $0x0,-0xd8(%rbp)
je     2a92 <main+0x1942>
mov    -0xb8(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     29c1 <main+0x1871>
mov    -0xb0(%rbp),%esi
mov    -0xb4(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    -0xb0(%rbp),%edi
imul   -0xb4(%rbp),%edi
imul   -0xb8(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x1e9f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     2a27 <main+0x18d7>
mov    -0xb8(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2a27 <main+0x18d7>
mov    -0xb0(%rbp),%esi
mov    -0xb4(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    -0xb0(%rbp),%edi
imul   -0xb4(%rbp),%edi
mov    -0xb8(%rbp),%r8d
sub    -0x48(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x1e4f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     2a8d <main+0x193d>
mov    -0xb8(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     2a8d <main+0x193d>
mov    -0xb0(%rbp),%esi
mov    -0xb4(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    -0xb0(%rbp),%edi
imul   -0xb4(%rbp),%edi
mov    -0xb8(%rbp),%r8d
sub    -0x50(%rbp),%r8d
imul   %r8d,%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x1dff(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2a92 <main+0x1942>
lea    0x1e02(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1dff(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1060 <scanf@plt>
jmp    340b <main+0x22bb>
lea    0x1ded(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1e08(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1ab3(%rip),%rdi
lea    -0xdc(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x1e00(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1a92(%rip),%rdi
lea    -0xe0(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x1df8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1a71(%rip),%rdi
lea    -0xe4(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x1df0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1a50(%rip),%rdi
lea    -0xe8(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x1de8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1a2f(%rip),%rdi
lea    -0xec(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x1de0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1a0e(%rip),%rdi
lea    -0xf0(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x1dd8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x19ed(%rip),%rdi
lea    -0xf4(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x1dd0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x19cc(%rip),%rdi
lea    -0xf8(%rbp),%rsi
call   1060 <scanf@plt>
xor    %eax,%eax
cmp    -0xdc(%rbp),%eax
jg     2d0e <main+0x1bbe>
cmpl   $0xff,-0xdc(%rbp)
jg     2d0e <main+0x1bbe>
xor    %eax,%eax
cmp    -0xe0(%rbp),%eax
jg     2d0e <main+0x1bbe>
cmpl   $0xff,-0xe0(%rbp)
jg     2d0e <main+0x1bbe>
xor    %eax,%eax
cmp    -0xe4(%rbp),%eax
jg     2d0e <main+0x1bbe>
cmpl   $0xff,-0xe4(%rbp)
jg     2d0e <main+0x1bbe>
xor    %eax,%eax
cmp    -0xe8(%rbp),%eax
jg     2d0e <main+0x1bbe>
cmpl   $0xff,-0xe8(%rbp)
jg     2d0e <main+0x1bbe>
xor    %eax,%eax
cmp    -0xec(%rbp),%eax
jg     2d0e <main+0x1bbe>
cmpl   $0xff,-0xec(%rbp)
jg     2d0e <main+0x1bbe>
xor    %eax,%eax
cmp    -0xf0(%rbp),%eax
jg     2d0e <main+0x1bbe>
cmpl   $0xff,-0xf0(%rbp)
jg     2d0e <main+0x1bbe>
xor    %eax,%eax
cmp    -0xf4(%rbp),%eax
jg     2d0e <main+0x1bbe>
cmpl   $0xff,-0xf4(%rbp)
jg     2d0e <main+0x1bbe>
xor    %eax,%eax
cmp    -0xf8(%rbp),%eax
jg     2d0e <main+0x1bbe>
cmpl   $0xff,-0xf8(%rbp)
jg     2d0e <main+0x1bbe>
mov    -0xdc(%rbp),%esi
mov    -0xe0(%rbp),%edx
mov    -0xe4(%rbp),%ecx
mov    -0xe8(%rbp),%r8d
lea    0x15a0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xec(%rbp),%esi
mov    -0xf0(%rbp),%edx
mov    -0xf4(%rbp),%ecx
mov    -0xf8(%rbp),%r8d
lea    0x15ad(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2d63 <main+0x1c13>
movl   $0xffffffff,-0xdc(%rbp)
ff ff ff
movl   $0xffffffff,-0xe0(%rbp)
ff ff ff
movl   $0xffffffff,-0xe4(%rbp)
ff ff ff
movl   $0xffffffff,-0xe8(%rbp)
ff ff ff
movl   $0xffffffff,-0xec(%rbp)
ff ff ff
movl   $0xffffffff,-0xf0(%rbp)
ff ff ff
movl   $0xffffffff,-0xf4(%rbp)
ff ff ff
movl   $0xffffffff,-0xf8(%rbp)
ff ff ff
jmp    2ac3 <main+0x1973>
jmp    340b <main+0x22bb>
cmpl   $0x0,-0xbc(%rbp)
je     2e17 <main+0x1cc7>
mov    -0x64(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2d9e <main+0x1c4e>
mov    -0xdc(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x60(%rbp),%ecx
imul   -0x64(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x64(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     2dd8 <main+0x1c88>
mov    -0x64(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2dd8 <main+0x1c88>
mov    -0xdc(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x64(%rbp),%esi
sub    -0x48(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x64(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     2e12 <main+0x1cc2>
mov    -0x64(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     2e12 <main+0x1cc2>
mov    -0xdc(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x64(%rbp),%esi
sub    -0x50(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    2e17 <main+0x1cc7>
cmpl   $0x0,-0xc0(%rbp)
je     2ec6 <main+0x1d76>
mov    -0x70(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2e4d <main+0x1cfd>
mov    -0xe0(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   -0x70(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x70(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     2e87 <main+0x1d37>
mov    -0x70(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2e87 <main+0x1d37>
mov    -0xe0(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%esi
sub    -0x48(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x70(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     2ec1 <main+0x1d71>
mov    -0x70(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     2ec1 <main+0x1d71>
mov    -0xe0(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%esi
sub    -0x50(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    2ec6 <main+0x1d76>
cmpl   $0x0,-0xc4(%rbp)
je     2f75 <main+0x1e25>
mov    -0x7c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2efc <main+0x1dac>
mov    -0xe4(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x78(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x7c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     2f36 <main+0x1de6>
mov    -0x7c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2f36 <main+0x1de6>
mov    -0xe4(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x7c(%rbp),%esi
sub    -0x48(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x7c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     2f70 <main+0x1e20>
mov    -0x7c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     2f70 <main+0x1e20>
mov    -0xe4(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x7c(%rbp),%esi
sub    -0x50(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    2f75 <main+0x1e25>
cmpl   $0x0,-0xc8(%rbp)
je     3045 <main+0x1ef5>
mov    -0x88(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2fb4 <main+0x1e64>
mov    -0xe8(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x84(%rbp),%ecx
imul   -0x88(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     2ffa <main+0x1eaa>
mov    -0x88(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2ffa <main+0x1eaa>
mov    -0xe8(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x84(%rbp),%ecx
mov    -0x88(%rbp),%esi
sub    -0x48(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     3040 <main+0x1ef0>
mov    -0x88(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     3040 <main+0x1ef0>
mov    -0xe8(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x84(%rbp),%ecx
mov    -0x88(%rbp),%esi
sub    -0x50(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    3045 <main+0x1ef5>
cmpl   $0x0,-0xcc(%rbp)
je     311e <main+0x1fce>
mov    -0x94(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3087 <main+0x1f37>
mov    -0xec(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x90(%rbp),%ecx
imul   -0x94(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x94(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     30d0 <main+0x1f80>
mov    -0x94(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     30d0 <main+0x1f80>
mov    -0xec(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x90(%rbp),%ecx
mov    -0x94(%rbp),%esi
sub    -0x48(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x94(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     3119 <main+0x1fc9>
mov    -0x94(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     3119 <main+0x1fc9>
mov    -0xec(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x90(%rbp),%ecx
mov    -0x94(%rbp),%esi
sub    -0x50(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    311e <main+0x1fce>
cmpl   $0x0,-0xd0(%rbp)
je     31fd <main+0x20ad>
mov    -0xa0(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3160 <main+0x2010>
mov    -0xf0(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
imul   -0xa0(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xa0(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     31ac <main+0x205c>
mov    -0xa0(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     31ac <main+0x205c>
mov    -0xf0(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
mov    -0xa0(%rbp),%esi
sub    $0x26c,%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xa0(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     31f8 <main+0x20a8>
mov    -0xa0(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     31f8 <main+0x20a8>
mov    -0xf0(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
mov    -0xa0(%rbp),%esi
sub    $0x4d8,%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    31fd <main+0x20ad>
cmpl   $0x0,-0xd4(%rbp)
je     32d6 <main+0x2186>
mov    -0xac(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     323f <main+0x20ef>
mov    -0xf4(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
imul   -0xac(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xac(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     3288 <main+0x2138>
mov    -0xac(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     3288 <main+0x2138>
mov    -0xf4(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
mov    -0xac(%rbp),%esi
sub    -0x48(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xac(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     32d1 <main+0x2181>
mov    -0xac(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     32d1 <main+0x2181>
mov    -0xf4(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
mov    -0xac(%rbp),%esi
sub    -0x50(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    32d6 <main+0x2186>
cmpl   $0x0,-0xd8(%rbp)
je     33af <main+0x225f>
mov    -0xb8(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3318 <main+0x21c8>
mov    -0xf8(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0xb0(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
imul   -0xb8(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xb8(%rbp),%eax
cmp    -0x48(%rbp),%eax
jl     3361 <main+0x2211>
mov    -0xb8(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     3361 <main+0x2211>
mov    -0xf8(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0xb0(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
mov    -0xb8(%rbp),%esi
sub    -0x48(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xb8(%rbp),%eax
cmp    -0x50(%rbp),%eax
jl     33aa <main+0x225a>
mov    -0xb8(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     33aa <main+0x225a>
mov    -0xf8(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0xb0(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
mov    -0xb8(%rbp),%esi
sub    -0x50(%rbp),%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    33af <main+0x225f>
lea    0x14e5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x14e2(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1060 <scanf@plt>
jmp    340b <main+0x22bb>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
lea    0x15a6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x110,%rsp
pop    %rbp
ret
jmp    1411 <main+0x2c1>
jmp    1411 <main+0x2c1>
lea    0x1590(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    341e <main+0x22ce>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    $0xaa5aa7d,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    $0xaa5aa7d,%edi
call   1070 <malloc@plt>
mov    %rax,%rbp
mov    $0xaa5aa7d,%edi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    $0xaa5aa7d,%edx
mov    %rbx,0x60(%rsp)
mov    %rbx,%rdi
mov    $0xa,%esi
call   1060 <memset@plt>
mov    $0xaa5aa7d,%edx
mov    %rbp,0x58(%rsp)
mov    %rbp,%rdi
mov    $0x14,%esi
call   1060 <memset@plt>
mov    $0xaa5aa7d,%edx
mov    %r14,0x50(%rsp)
mov    %r14,%rdi
mov    $0x1e,%esi
call   1060 <memset@plt>
movl   $0xaa5aa7d,0xb4(%rsp)
7d aa a5 0a
lea    0x1e31(%rip),%rdi
mov    $0xaa5aa7d,%esi
mov    $0xaa,%edx
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x2729(%rip),%rdi
call   1040 <puts@plt>
mov    $0x5,%edi
call   1090 <sleep@plt>
movl   $0xffffffff,0x4c(%rsp)
ff
movl   $0xffffffff,0x48(%rsp)
ff
movl   $0xffffffff,0x80(%rsp)
ff ff ff ff
movl   $0xffffffff,0x44(%rsp)
ff
movl   $0xffffffff,0x40(%rsp)
ff
movl   $0xffffffff,0x7c(%rsp)
ff
movl   $0xffffffff,0x3c(%rsp)
ff
movl   $0xffffffff,0x38(%rsp)
ff
movl   $0xffffffff,0x78(%rsp)
ff
movl   $0xffffffff,0x34(%rsp)
ff
movl   $0xffffffff,0x30(%rsp)
ff
movl   $0xffffffff,0x2c(%rsp)
ff
movl   $0xffffffff,0x28(%rsp)
ff
movl   $0xffffffff,0x24(%rsp)
ff
movl   $0xffffffff,0x74(%rsp)
ff
movl   $0xffffffff,0x20(%rsp)
ff
movl   $0xffffffff,0x1c(%rsp)
ff
movl   $0xffffffff,0x70(%rsp)
ff
movl   $0xffffffff,0x18(%rsp)
ff
movl   $0xffffffff,0x14(%rsp)
ff
movl   $0xffffffff,0x6c(%rsp)
ff
movl   $0xffffffff,0x10(%rsp)
ff
movl   $0xffffffff,0xc(%rsp)
ff
movl   $0xffffffff,0x68(%rsp)
ff
movl   $0xffffffff,0xa0(%rsp)
ff ff ff ff
movl   $0xffffffff,0x9c(%rsp)
ff ff ff ff
movl   $0xffffffff,0x98(%rsp)
ff ff ff ff
movl   $0xffffffff,0x94(%rsp)
ff ff ff ff
movl   $0xffffffff,0x90(%rsp)
ff ff ff ff
movl   $0xffffffff,0x8c(%rsp)
ff ff ff ff
movl   $0xffffffff,0x88(%rsp)
ff ff ff ff
movl   $0xffffffff,0x84(%rsp)
ff ff ff ff
movl   $0x0,0xb0(%rsp)
lea    0x1e45(%rip),%r13
jmp    1390 <main+0x220>
imul   0x10(%rsp),%eax
imul   0xc(%rsp),%eax
mov    0x60(%rsp),%rcx
mov    0x84(%rsp),%dl
cltq
mov    %dl,(%rcx,%rax,1)
lea    0x241f(%rip),%rdi
call   1040 <puts@plt>
lea    0x2085(%rip),%rdi
lea    0xb4(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1cd2(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x4c(%rsp),%esi
test   %esi,%esi
js     13f0 <main+0x280>
cmp    $0x32a,%esi
ja     13f0 <main+0x280>
mov    0x48(%rsp),%edx
test   %edx,%edx
js     13f0 <main+0x280>
cmp    $0x32a,%edx
ja     13f0 <main+0x280>
mov    0x80(%rsp),%ecx
test   %ecx,%ecx
js     13f0 <main+0x280>
cmp    $0x32b,%ecx
jge    13f0 <main+0x280>
xor    %r12d,%r12d
lea    0x1c99(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    13ff <main+0x28f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x2528(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%r12b
mov    0x44(%rsp),%esi
test   %esi,%esi
js     1450 <main+0x2e0>
cmp    $0x32a,%esi
ja     1450 <main+0x2e0>
mov    0x40(%rsp),%edx
test   %edx,%edx
js     1450 <main+0x2e0>
cmp    $0x32a,%edx
ja     1450 <main+0x2e0>
mov    0x7c(%rsp),%ecx
test   %ecx,%ecx
js     1450 <main+0x2e0>
cmp    $0x32b,%ecx
jge    1450 <main+0x2e0>
xor    %r14d,%r14d
lea    0x1c52(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    145f <main+0x2ef>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x24a7(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%r14b
mov    0x3c(%rsp),%esi
test   %esi,%esi
js     14b0 <main+0x340>
cmp    $0x32a,%esi
ja     14b0 <main+0x340>
mov    0x38(%rsp),%edx
test   %edx,%edx
js     14b0 <main+0x340>
cmp    $0x32a,%edx
ja     14b0 <main+0x340>
mov    0x78(%rsp),%ecx
test   %ecx,%ecx
js     14b0 <main+0x340>
cmp    $0x32b,%ecx
jge    14b0 <main+0x340>
xor    %ebx,%ebx
lea    0x1c0a(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    14be <main+0x34e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x2426(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%bl
mov    0x34(%rsp),%esi
test   %esi,%esi
js     1510 <main+0x3a0>
cmp    $0x32a,%esi
ja     1510 <main+0x3a0>
mov    0x30(%rsp),%edx
test   %edx,%edx
js     1510 <main+0x3a0>
cmp    $0x32a,%edx
ja     1510 <main+0x3a0>
mov    0x2c(%rsp),%ecx
test   %ecx,%ecx
js     1510 <main+0x3a0>
cmp    $0x32b,%ecx
jge    1510 <main+0x3a0>
xor    %r15d,%r15d
lea    0x1bc1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    151f <main+0x3af>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x23a5(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%r15b
mov    0x28(%rsp),%esi
test   %esi,%esi
js     1570 <main+0x400>
cmp    $0x32a,%esi
ja     1570 <main+0x400>
mov    0x24(%rsp),%edx
test   %edx,%edx
js     1570 <main+0x400>
cmp    $0x32a,%edx
ja     1570 <main+0x400>
mov    0x74(%rsp),%ecx
test   %ecx,%ecx
js     1570 <main+0x400>
cmp    $0x32b,%ecx
jge    1570 <main+0x400>
xor    %ebp,%ebp
lea    0x1b78(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    157f <main+0x40f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x2324(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%bpl
mov    0x20(%rsp),%esi
test   %esi,%esi
js     15d0 <main+0x460>
cmp    $0x32a,%esi
ja     15d0 <main+0x460>
mov    0x1c(%rsp),%edx
test   %edx,%edx
js     15d0 <main+0x460>
cmp    $0x32a,%edx
ja     15d0 <main+0x460>
mov    0x70(%rsp),%ecx
test   %ecx,%ecx
js     15d0 <main+0x460>
cmp    $0x32b,%ecx
jge    15d0 <main+0x460>
movl   $0x0,0xa4(%rsp)
lea    0x1b26(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    15e5 <main+0x475>
nopw   0x0(%rax,%rax,1)
lea    0x22a3(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%al
mov    %eax,0xa4(%rsp)
mov    0x18(%rsp),%esi
test   %esi,%esi
js     1640 <main+0x4d0>
cmp    $0x32a,%esi
ja     1640 <main+0x4d0>
mov    0x14(%rsp),%edx
test   %edx,%edx
js     1640 <main+0x4d0>
cmp    $0x32a,%edx
ja     1640 <main+0x4d0>
mov    0x6c(%rsp),%ecx
test   %ecx,%ecx
js     1640 <main+0x4d0>
cmpl   $0x32b,0x2c(%rsp)
jge    1640 <main+0x4d0>
movl   $0x0,0xa8(%rsp)
lea    0x1ad5(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1655 <main+0x4e5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x2212(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%al
mov    %eax,0xa8(%rsp)
mov    0x10(%rsp),%esi
test   %esi,%esi
js     16a0 <main+0x530>
cmp    $0x32a,%esi
ja     16a0 <main+0x530>
mov    0xc(%rsp),%edx
test   %edx,%edx
js     16a0 <main+0x530>
cmp    $0x32a,%edx
ja     16a0 <main+0x530>
mov    0x68(%rsp),%ecx
test   %ecx,%ecx
js     16a0 <main+0x530>
cmp    $0x32b,%ecx
jge    16a0 <main+0x530>
movl   $0x0,0xac(%rsp)
lea    0x1a7e(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    16b5 <main+0x545>
lea    0x2191(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%al
mov    %eax,0xac(%rsp)
mov    0xa0(%rsp),%esi
cmp    $0xff,%esi
ja     179d <main+0x62d>
mov    0x9c(%rsp),%edx
test   %edx,%edx
js     179d <main+0x62d>
cmp    $0xff,%edx
jg     179d <main+0x62d>
mov    0x98(%rsp),%ecx
test   %ecx,%ecx
js     179d <main+0x62d>
cmp    $0xff,%ecx
jg     179d <main+0x62d>
mov    0x94(%rsp),%r8d
test   %r8d,%r8d
js     179d <main+0x62d>
cmp    $0xff,%r8d
jg     179d <main+0x62d>
mov    0x90(%rsp),%eax
test   %eax,%eax
js     179d <main+0x62d>
cmp    $0xff,%eax
jg     179d <main+0x62d>
mov    0x8c(%rsp),%eax
test   %eax,%eax
js     179d <main+0x62d>
cmp    $0xff,%eax
jg     179d <main+0x62d>
mov    0x88(%rsp),%eax
test   %eax,%eax
js     179d <main+0x62d>
cmp    $0xff,%eax
jg     179d <main+0x62d>
mov    0x84(%rsp),%eax
test   %eax,%eax
js     179d <main+0x62d>
cmp    $0xff,%eax
jg     179d <main+0x62d>
lea    0x19c1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x90(%rsp),%esi
mov    0x8c(%rsp),%edx
mov    0x88(%rsp),%ecx
mov    0x84(%rsp),%r8d
lea    0x19ca(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1c67(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c61(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c98(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ccf(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d06(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d3d(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d75(%rip),%rdi
call   1040 <puts@plt>
lea    0x1dad(%rip),%rdi
call   1040 <puts@plt>
lea    0x1de5(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e1d(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e2d(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e47(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e64(%rip),%rdi
call   1040 <puts@plt>
lea    0x1959(%rip),%rdi
lea    0xb0(%rsp),%rsi
call   1080 <scanf@plt>
mov    0xb0(%rsp),%eax
cmp    $0xb,%rax
ja     1390 <main+0x220>
lea    0x179b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x191f(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x4c(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x190c(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x48(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x18f5(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x80(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x4c(%rsp),%eax
test   %eax,%eax
js     18f6 <main+0x786>
cmp    $0x32a,%eax
ja     18f6 <main+0x786>
mov    0x48(%rsp),%eax
test   %eax,%eax
js     18f6 <main+0x786>
cmp    $0x32a,%eax
ja     18f6 <main+0x786>
mov    0x80(%rsp),%eax
test   %eax,%eax
js     18f6 <main+0x786>
cmp    $0x32b,%eax
jl     1390 <main+0x220>
lea    0x1f28(%rip),%rdi
call   1040 <puts@plt>
movl   $0xffffffff,0x4c(%rsp)
ff
movl   $0xffffffff,0x48(%rsp)
ff
movl   $0xffffffff,0x80(%rsp)
ff ff ff ff
jmp    1390 <main+0x220>
lea    0x187b(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x44(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1864(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x40(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x184d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x7c(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x44(%rsp),%eax
test   %eax,%eax
js     19a4 <main+0x834>
cmp    $0x32a,%eax
ja     19a4 <main+0x834>
mov    0x40(%rsp),%eax
test   %eax,%eax
js     19a4 <main+0x834>
cmp    $0x32a,%eax
ja     19a4 <main+0x834>
mov    0x7c(%rsp),%eax
test   %eax,%eax
js     19a4 <main+0x834>
cmp    $0x32b,%eax
jl     1390 <main+0x220>
lea    0x1e67(%rip),%rdi
call   1040 <puts@plt>
movl   $0xffffffff,0x44(%rsp)
ff
movl   $0xffffffff,0x40(%rsp)
ff
movl   $0xffffffff,0x7c(%rsp)
ff
jmp    1390 <main+0x220>
lea    0x17e8(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x34(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x17d1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x30(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x17ba(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x2c(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x34(%rsp),%eax
test   %eax,%eax
js     1a4f <main+0x8df>
cmp    $0x32a,%eax
ja     1a4f <main+0x8df>
mov    0x30(%rsp),%eax
test   %eax,%eax
js     1a4f <main+0x8df>
cmp    $0x32a,%eax
ja     1a4f <main+0x8df>
mov    0x2c(%rsp),%eax
test   %eax,%eax
js     1a4f <main+0x8df>
cmp    $0x32b,%eax
jl     1390 <main+0x220>
lea    0x1d96(%rip),%rdi
call   1040 <puts@plt>
movl   $0xffffffff,0x34(%rsp)
ff
movl   $0xffffffff,0x30(%rsp)
ff
movl   $0xffffffff,0x2c(%rsp)
ff
jmp    1390 <main+0x220>
lea    0x1c2f(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c4b(%rip),%r14
lea    0xa0(%rsp),%r15
lea    0x1c54(%rip),%r12
lea    0x9c(%rsp),%rbp
lea    0x1c5d(%rip),%rbx
jmp    1b08 <main+0x998>
nopl   0x0(%rax,%rax,1)
movl   $0xffffffff,0xa0(%rsp)
ff ff ff ff
movl   $0xffffffff,0x9c(%rsp)
ff ff ff ff
movl   $0xffffffff,0x98(%rsp)
ff ff ff ff
movl   $0xffffffff,0x94(%rsp)
ff ff ff ff
movl   $0xffffffff,0x90(%rsp)
ff ff ff ff
movl   $0xffffffff,0x8c(%rsp)
ff ff ff ff
movl   $0xffffffff,0x88(%rsp)
ff ff ff ff
movl   $0xffffffff,0x84(%rsp)
ff ff ff ff
mov    %r14,%rdi
call   1040 <puts@plt>
mov    %r13,%rdi
mov    %r15,%rsi
call   1080 <scanf@plt>
mov    %r12,%rdi
call   1040 <puts@plt>
mov    %r13,%rdi
mov    %rbp,%rsi
call   1080 <scanf@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    %r13,%rdi
lea    0x98(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1bd1(%rip),%rdi
call   1040 <puts@plt>
mov    %r13,%rdi
lea    0x94(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1bcd(%rip),%rdi
call   1040 <puts@plt>
mov    %r13,%rdi
lea    0x90(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1bc9(%rip),%rdi
call   1040 <puts@plt>
mov    %r13,%rdi
lea    0x8c(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1bc5(%rip),%rdi
call   1040 <puts@plt>
mov    %r13,%rdi
lea    0x88(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1bc1(%rip),%rdi
call   1040 <puts@plt>
mov    %r13,%rdi
lea    0x84(%rsp),%rsi
call   1080 <scanf@plt>
mov    0xa0(%rsp),%esi
cmp    $0xff,%esi
ja     1ab0 <main+0x940>
mov    0x9c(%rsp),%edx
test   %edx,%edx
js     1ab0 <main+0x940>
cmp    $0xff,%edx
jg     1ab0 <main+0x940>
mov    0x98(%rsp),%ecx
test   %ecx,%ecx
js     1ab0 <main+0x940>
cmp    $0xff,%ecx
jg     1ab0 <main+0x940>
mov    0x94(%rsp),%r8d
test   %r8d,%r8d
js     1ab0 <main+0x940>
cmp    $0xff,%r8d
jg     1ab0 <main+0x940>
mov    0x90(%rsp),%eax
test   %eax,%eax
js     1ab0 <main+0x940>
cmp    $0xff,%eax
jg     1ab0 <main+0x940>
mov    0x8c(%rsp),%eax
test   %eax,%eax
js     1ab0 <main+0x940>
cmp    $0xff,%eax
jg     1ab0 <main+0x940>
mov    0x88(%rsp),%eax
test   %eax,%eax
js     1ab0 <main+0x940>
cmp    $0xff,%eax
jg     1ab0 <main+0x940>
mov    0x84(%rsp),%eax
test   %eax,%eax
js     1ab0 <main+0x940>
cmp    $0xff,%eax
jg     1ab0 <main+0x940>
lea    0x1484(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x90(%rsp),%esi
mov    0x8c(%rsp),%edx
mov    0x88(%rsp),%ecx
mov    0x84(%rsp),%r8d
lea    0x148d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1390 <main+0x220>
test   %r12b,%r12b
jne    2665 <main+0x14f5>
mov    0x80(%rsp),%eax
cmp    $0x10d,%eax
jg     2621 <main+0x14b1>
imul   0x4c(%rsp),%eax
imul   0x48(%rsp),%eax
mov    0x60(%rsp),%rcx
jmp    2659 <main+0x14e9>
lea    0x149b(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x3c(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1484(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x38(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x146d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x78(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x3c(%rsp),%eax
test   %eax,%eax
js     1d90 <main+0xc20>
cmp    $0x32a,%eax
ja     1d90 <main+0xc20>
mov    0x38(%rsp),%eax
test   %eax,%eax
js     1d90 <main+0xc20>
cmp    $0x32a,%eax
ja     1d90 <main+0xc20>
mov    0x78(%rsp),%eax
test   %eax,%eax
js     1d90 <main+0xc20>
cmp    $0x32b,%eax
jl     1390 <main+0x220>
lea    0x1a68(%rip),%rdi
call   1040 <puts@plt>
movl   $0xffffffff,0x3c(%rsp)
ff
movl   $0xffffffff,0x38(%rsp)
ff
movl   $0xffffffff,0x78(%rsp)
ff
jmp    1390 <main+0x220>
lea    0x1408(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x28(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x13f1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x24(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x13da(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x74(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x28(%rsp),%eax
test   %eax,%eax
js     1e3b <main+0xccb>
cmp    $0x32a,%eax
ja     1e3b <main+0xccb>
mov    0x24(%rsp),%eax
test   %eax,%eax
js     1e3b <main+0xccb>
cmp    $0x32a,%eax
ja     1e3b <main+0xccb>
mov    0x74(%rsp),%eax
test   %eax,%eax
js     1e3b <main+0xccb>
cmp    $0x32b,%eax
jl     1390 <main+0x220>
lea    0x1997(%rip),%rdi
call   1040 <puts@plt>
movl   $0xffffffff,0x28(%rsp)
ff
movl   $0xffffffff,0x24(%rsp)
ff
movl   $0xffffffff,0x74(%rsp)
ff
jmp    1390 <main+0x220>
lea    0x1369(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x20(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1352(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x1c(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x133b(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x70(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x20(%rsp),%eax
test   %eax,%eax
js     1ee8 <main+0xd78>
cmp    $0x32a,%eax
ja     1ee8 <main+0xd78>
mov    0x1c(%rsp),%eax
test   %eax,%eax
js     1ee8 <main+0xd78>
cmp    $0x32a,%eax
ja     1ee8 <main+0xd78>
cmpl   $0x0,0x70(%rsp)
js     1ee8 <main+0xd78>
cmpl   $0x32b,0x2c(%rsp)
jl     1390 <main+0x220>
lea    0x18d7(%rip),%rdi
call   1040 <puts@plt>
movl   $0xffffffff,0x20(%rsp)
ff
movl   $0xffffffff,0x1c(%rsp)
ff
movl   $0xffffffff,0x70(%rsp)
ff
jmp    1390 <main+0x220>
lea    0x12c8(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x18(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x12b1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x14(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x129a(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x6c(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x18(%rsp),%eax
test   %eax,%eax
js     1f93 <main+0xe23>
cmp    $0x32a,%eax
ja     1f93 <main+0xe23>
mov    0x14(%rsp),%eax
test   %eax,%eax
js     1f93 <main+0xe23>
cmp    $0x32a,%eax
ja     1f93 <main+0xe23>
mov    0x6c(%rsp),%eax
test   %eax,%eax
js     1f93 <main+0xe23>
cmp    $0x32b,%eax
jl     1390 <main+0x220>
lea    0x1819(%rip),%rdi
call   1040 <puts@plt>
movl   $0xffffffff,0x18(%rsp)
ff
movl   $0xffffffff,0x14(%rsp)
ff
movl   $0xffffffff,0x6c(%rsp)
ff
jmp    1390 <main+0x220>
lea    0x1229(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x10(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x1212(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0xc(%rsp),%rsi
call   1080 <scanf@plt>
lea    0x11fb(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0x68(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x10(%rsp),%eax
test   %eax,%eax
js     203e <main+0xece>
cmp    $0x32a,%eax
ja     203e <main+0xece>
mov    0xc(%rsp),%eax
test   %eax,%eax
js     203e <main+0xece>
cmp    $0x32a,%eax
ja     203e <main+0xece>
mov    0x68(%rsp),%eax
test   %eax,%eax
js     203e <main+0xece>
cmp    $0x32b,%eax
jl     1390 <main+0x220>
lea    0x175b(%rip),%rdi
call   1040 <puts@plt>
movl   $0xffffffff,0x10(%rsp)
ff
movl   $0xffffffff,0xc(%rsp)
ff
movl   $0xffffffff,0x68(%rsp)
ff
jmp    1390 <main+0x220>
test   %r12b,%r12b
jne    2121 <main+0xfb1>
mov    0x80(%rsp),%ecx
cmp    $0x10d,%ecx
jg     20b0 <main+0xf40>
mov    0x4c(%rsp),%esi
mov    0x48(%rsp),%edx
mov    %esi,%eax
imul   %ecx,%eax
imul   %edx,%eax
cltq
mov    0x60(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x1156(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x80(%rsp),%ecx
lea    -0x10e(%rcx),%eax
cmp    $0x10d,%eax
ja     20ec <main+0xf7c>
mov    0x4c(%rsp),%esi
mov    0x48(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x58(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x1130(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x80(%rsp),%ecx
lea    -0x21c(%rcx),%eax
cmp    $0x10d,%eax
ja     2121 <main+0xfb1>
mov    0x4c(%rsp),%esi
mov    0x48(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x50(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x110a(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   %r14b,%r14b
jne    21d2 <main+0x1062>
mov    0x7c(%rsp),%ecx
cmp    $0x10d,%ecx
jg     2164 <main+0xff4>
mov    0x44(%rsp),%esi
mov    0x40(%rsp),%edx
mov    %esi,%eax
imul   %ecx,%eax
imul   %edx,%eax
cltq
mov    0x60(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x10e1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x7c(%rsp),%ecx
lea    -0x10e(%rcx),%eax
cmp    $0x10d,%eax
ja     219d <main+0x102d>
mov    0x44(%rsp),%esi
mov    0x40(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x58(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x10be(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x7c(%rsp),%ecx
lea    -0x21c(%rcx),%eax
cmp    $0x10d,%eax
ja     21d2 <main+0x1062>
mov    0x44(%rsp),%esi
mov    0x40(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x50(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x109b(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   %bl,%bl
jne    2282 <main+0x1112>
mov    0x78(%rsp),%ecx
cmp    $0x10d,%ecx
jg     2214 <main+0x10a4>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
mov    %esi,%eax
imul   %ecx,%eax
imul   %edx,%eax
cltq
mov    0x60(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x1073(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x78(%rsp),%ecx
lea    -0x10e(%rcx),%eax
cmp    $0x10d,%eax
ja     224d <main+0x10dd>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x58(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x1050(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x78(%rsp),%ecx
lea    -0x21c(%rcx),%eax
cmp    $0x10d,%eax
ja     2282 <main+0x1112>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x50(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x102d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   %r15b,%r15b
jne    2333 <main+0x11c3>
mov    0x2c(%rsp),%ecx
cmp    $0x10d,%ecx
jg     22c5 <main+0x1155>
mov    0x34(%rsp),%esi
mov    0x30(%rsp),%edx
mov    %esi,%eax
imul   %ecx,%eax
imul   %edx,%eax
cltq
mov    0x60(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0x1004(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x2c(%rsp),%ecx
lea    -0x10e(%rcx),%eax
cmp    $0x10d,%eax
ja     22fe <main+0x118e>
mov    0x34(%rsp),%esi
mov    0x30(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x58(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xfe1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x2c(%rsp),%ecx
lea    -0x21c(%rcx),%eax
cmp    $0x10d,%eax
ja     2333 <main+0x11c3>
mov    0x34(%rsp),%esi
mov    0x30(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x50(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xfbe(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   %bpl,%bpl
jne    23e4 <main+0x1274>
mov    0x74(%rsp),%ecx
cmp    $0x10d,%ecx
jg     2376 <main+0x1206>
mov    0x28(%rsp),%esi
mov    0x24(%rsp),%edx
mov    %esi,%eax
imul   %ecx,%eax
imul   %edx,%eax
cltq
mov    0x60(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xf95(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x74(%rsp),%ecx
lea    -0x10e(%rcx),%eax
cmp    $0x10d,%eax
ja     23af <main+0x123f>
mov    0x28(%rsp),%esi
mov    0x24(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x58(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xf72(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x74(%rsp),%ecx
lea    -0x21c(%rcx),%eax
cmp    $0x10d,%eax
ja     23e4 <main+0x1274>
mov    0x28(%rsp),%esi
mov    0x24(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x50(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xf4f(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpb   $0x0,0xa4(%rsp)
jne    249a <main+0x132a>
mov    0x70(%rsp),%ecx
cmp    $0x10d,%ecx
jg     242c <main+0x12bc>
mov    0x20(%rsp),%esi
mov    0x1c(%rsp),%edx
mov    %esi,%eax
imul   %ecx,%eax
imul   %edx,%eax
cltq
mov    0x60(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xf21(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x70(%rsp),%ecx
lea    -0x10e(%rcx),%eax
cmp    $0x10d,%eax
ja     2465 <main+0x12f5>
mov    0x20(%rsp),%esi
mov    0x1c(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x58(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xefe(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x70(%rsp),%ecx
lea    -0x21c(%rcx),%eax
cmp    $0x10d,%eax
ja     249a <main+0x132a>
mov    0x20(%rsp),%esi
mov    0x1c(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x50(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xedb(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpb   $0x0,0xa8(%rsp)
jne    2562 <main+0x13f2>
mov    0x6c(%rsp),%ecx
cmp    $0x10d,%ecx
jg     24e2 <main+0x1372>
mov    0x18(%rsp),%esi
mov    0x14(%rsp),%edx
mov    %esi,%eax
imul   %ecx,%eax
imul   %edx,%eax
cltq
mov    0x60(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xead(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x6c(%rsp),%ecx
lea    -0x10e(%rcx),%eax
cmp    $0x10d,%eax
ja     2524 <main+0x13b4>
mov    0x18(%rsp),%esi
mov    0x14(%rsp),%edx
lea    -0x26c(%rcx),%eax
mov    %esi,%edi
imul   %edx,%edi
imul   %eax,%edi
movslq %edi,%rax
mov    0x58(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xe81(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x6c(%rsp),%ecx
lea    -0x21c(%rcx),%eax
cmp    $0x10d,%eax
ja     2562 <main+0x13f2>
mov    0x18(%rsp),%esi
mov    0x14(%rsp),%edx
lea    -0x4d8(%rcx),%eax
mov    %esi,%edi
imul   %edx,%edi
imul   %eax,%edi
movslq %edi,%rax
mov    0x50(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xe55(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpb   $0x0,0xac(%rsp)
jne    1370 <main+0x200>
mov    0x68(%rsp),%ecx
cmp    $0x10d,%ecx
jg     25aa <main+0x143a>
mov    0x10(%rsp),%esi
mov    0xc(%rsp),%edx
mov    %esi,%eax
imul   %ecx,%eax
imul   %edx,%eax
cltq
mov    0x60(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xe27(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x68(%rsp),%ecx
lea    -0x10e(%rcx),%eax
cmp    $0x10d,%eax
ja     25e3 <main+0x1473>
mov    0x10(%rsp),%esi
mov    0xc(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x58(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xe04(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x68(%rsp),%ecx
lea    -0x21c(%rcx),%eax
cmp    $0x10d,%eax
ja     1370 <main+0x200>
mov    0x10(%rsp),%esi
mov    0xc(%rsp),%edx
imul   %esi,%eax
imul   %edx,%eax
cltq
mov    0x50(%rsp),%rdi
movsbl (%rdi,%rax,1),%r8d
lea    0xddd(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1370 <main+0x200>
cmp    $0x21b,%eax
ja     263e <main+0x14ce>
add    $0xfffffef2,%eax
imul   0x4c(%rsp),%eax
imul   0x48(%rsp),%eax
mov    0x58(%rsp),%rcx
jmp    2659 <main+0x14e9>
cmp    $0x329,%eax
ja     2665 <main+0x14f5>
add    $0xfffffde4,%eax
imul   0x4c(%rsp),%eax
imul   0x48(%rsp),%eax
mov    0x50(%rsp),%rcx
mov    0xa0(%rsp),%dl
cltq
mov    %dl,(%rcx,%rax,1)
test   %r14b,%r14b
jne    26ca <main+0x155a>
mov    0x7c(%rsp),%eax
cmp    $0x10d,%eax
jg     2686 <main+0x1516>
imul   0x44(%rsp),%eax
imul   0x40(%rsp),%eax
mov    0x60(%rsp),%rcx
jmp    26be <main+0x154e>
cmp    $0x21b,%eax
ja     26a3 <main+0x1533>
add    $0xfffffef2,%eax
imul   0x44(%rsp),%eax
imul   0x40(%rsp),%eax
mov    0x58(%rsp),%rcx
jmp    26be <main+0x154e>
cmp    $0x329,%eax
ja     26ca <main+0x155a>
add    $0xfffffde4,%eax
imul   0x44(%rsp),%eax
imul   0x40(%rsp),%eax
mov    0x50(%rsp),%rcx
mov    0x9c(%rsp),%dl
cltq
mov    %dl,(%rcx,%rax,1)
test   %bl,%bl
jne    272e <main+0x15be>
mov    0x78(%rsp),%eax
cmp    $0x10d,%eax
jg     26ea <main+0x157a>
imul   0x3c(%rsp),%eax
imul   0x38(%rsp),%eax
mov    0x60(%rsp),%rcx
jmp    2722 <main+0x15b2>
cmp    $0x21b,%eax
ja     2707 <main+0x1597>
add    $0xfffffef2,%eax
imul   0x3c(%rsp),%eax
imul   0x38(%rsp),%eax
mov    0x58(%rsp),%rcx
jmp    2722 <main+0x15b2>
cmp    $0x329,%eax
ja     272e <main+0x15be>
add    $0xfffffde4,%eax
imul   0x3c(%rsp),%eax
imul   0x38(%rsp),%eax
mov    0x50(%rsp),%rcx
mov    0x98(%rsp),%dl
cltq
mov    %dl,(%rcx,%rax,1)
test   %r15b,%r15b
jne    2793 <main+0x1623>
mov    0x2c(%rsp),%eax
cmp    $0x10d,%eax
jg     274f <main+0x15df>
imul   0x34(%rsp),%eax
imul   0x30(%rsp),%eax
mov    0x60(%rsp),%rcx
jmp    2787 <main+0x1617>
cmp    $0x21b,%eax
ja     276c <main+0x15fc>
add    $0xfffffef2,%eax
imul   0x34(%rsp),%eax
imul   0x30(%rsp),%eax
mov    0x58(%rsp),%rcx
jmp    2787 <main+0x1617>
cmp    $0x329,%eax
ja     2793 <main+0x1623>
add    $0xfffffde4,%eax
imul   0x34(%rsp),%eax
imul   0x30(%rsp),%eax
mov    0x50(%rsp),%rcx
mov    0x94(%rsp),%dl
cltq
mov    %dl,(%rcx,%rax,1)
test   %bpl,%bpl
jne    27f8 <main+0x1688>
mov    0x74(%rsp),%eax
cmp    $0x10d,%eax
jg     27b4 <main+0x1644>
imul   0x28(%rsp),%eax
imul   0x24(%rsp),%eax
mov    0x60(%rsp),%rcx
jmp    27ec <main+0x167c>
cmp    $0x21b,%eax
ja     27d1 <main+0x1661>
add    $0xfffffef2,%eax
imul   0x28(%rsp),%eax
imul   0x24(%rsp),%eax
mov    0x58(%rsp),%rcx
jmp    27ec <main+0x167c>
cmp    $0x329,%eax
ja     27f8 <main+0x1688>
add    $0xfffffde4,%eax
imul   0x28(%rsp),%eax
imul   0x24(%rsp),%eax
mov    0x50(%rsp),%rcx
mov    0x90(%rsp),%dl
cltq
mov    %dl,(%rcx,%rax,1)
cmpb   $0x0,0xa4(%rsp)
jne    2862 <main+0x16f2>
mov    0x70(%rsp),%eax
cmp    $0x10d,%eax
jg     281e <main+0x16ae>
imul   0x20(%rsp),%eax
imul   0x1c(%rsp),%eax
mov    0x60(%rsp),%rcx
jmp    2856 <main+0x16e6>
cmp    $0x21b,%eax
ja     283b <main+0x16cb>
add    $0xfffffd94,%eax
imul   0x20(%rsp),%eax
imul   0x1c(%rsp),%eax
mov    0x58(%rsp),%rcx
jmp    2856 <main+0x16e6>
cmp    $0x329,%eax
ja     2862 <main+0x16f2>
add    $0xfffffb28,%eax
imul   0x20(%rsp),%eax
imul   0x1c(%rsp),%eax
mov    0x50(%rsp),%rcx
mov    0x8c(%rsp),%dl
cltq
mov    %dl,(%rcx,%rax,1)
cmpb   $0x0,0xa8(%rsp)
jne    28cc <main+0x175c>
mov    0x6c(%rsp),%eax
cmp    $0x10d,%eax
jg     2888 <main+0x1718>
imul   0x18(%rsp),%eax
imul   0x14(%rsp),%eax
mov    0x60(%rsp),%rcx
jmp    28c0 <main+0x1750>
cmp    $0x21b,%eax
ja     28a5 <main+0x1735>
add    $0xfffffef2,%eax
imul   0x18(%rsp),%eax
imul   0x14(%rsp),%eax
mov    0x58(%rsp),%rcx
jmp    28c0 <main+0x1750>
cmp    $0x329,%eax
ja     28cc <main+0x175c>
add    $0xfffffde4,%eax
imul   0x18(%rsp),%eax
imul   0x14(%rsp),%eax
mov    0x50(%rsp),%rcx
mov    0x88(%rsp),%dl
cltq
mov    %dl,(%rcx,%rax,1)
cmpb   $0x0,0xac(%rsp)
jne    1370 <main+0x200>
mov    0x68(%rsp),%eax
cmp    $0x10d,%eax
jle    1355 <main+0x1e5>
cmp    $0x21b,%eax
ja     2909 <main+0x1799>
add    $0xfffffef2,%eax
imul   0x10(%rsp),%eax
imul   0xc(%rsp),%eax
mov    0x58(%rsp),%rcx
jmp    1364 <main+0x1f4>
cmp    $0x329,%eax
ja     1370 <main+0x200>
add    $0xfffffde4,%eax
imul   0x10(%rsp),%eax
imul   0xc(%rsp),%eax
mov    0x50(%rsp),%rcx
jmp    1364 <main+0x1f4>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
lea    0xd50(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [57 x i8] c"c1,c2,c3 arrays mem alloc 3 x %d bytes (3 x %dMB) done!\0A\00"
@.str.1 = [63 x i8] c"so you get cube 812 x 812 x 812 witch cells 8-bits each wide\0A\0A\00"
@.str.2 = [11 x i8] c"\1B[1;1H\1B[2J\00"
@.str.3 = [34 x i8] c"P1: niekre\C5\9Blono wp\C3\B3\C5\82rz\C4\99dnych\0A\00"
@.str.4 = [23 x i8] c"P1: x1=%d\09y1=%d\09z1=%d\0A\00"
@.str.5 = [34 x i8] c"P2: niekre\C5\9Blono wp\C3\B3\C5\82rz\C4\99dnych\0A\00"
@.str.6 = [23 x i8] c"P2: x2=%d\09y2=%d\09z2=%d\0A\00"
@.str.7 = [34 x i8] c"P3: niekre\C5\9Blono wp\C3\B3\C5\82rz\C4\99dnych\0A\00"
@.str.8 = [23 x i8] c"P3: x3=%d\09y3=%d\09z3=%d\0A\00"
@.str.9 = [34 x i8] c"P4: niekre\C5\9Blono wp\C3\B3\C5\82rz\C4\99dnych\0A\00"
@.str.10 = [23 x i8] c"P4: x4=%d\09y4=%d\09z4=%d\0A\00"
@.str.11 = [34 x i8] c"P5: niekre\C5\9Blono wp\C3\B3\C5\82rz\C4\99dnych\0A\00"
@.str.12 = [23 x i8] c"P5: x5=%d\09y5=%d\09z5=%d\0A\00"
@.str.13 = [34 x i8] c"P6: niekre\C5\9Blono wp\C3\B3\C5\82rz\C4\99dnych\0A\00"
@.str.14 = [23 x i8] c"P6: x6=%d\09y6=%d\09z6=%d\0A\00"
@.str.15 = [34 x i8] c"P7: niekre\C5\9Blono wp\C3\B3\C5\82rz\C4\99dnych\0A\00"
@.str.16 = [23 x i8] c"P7: x7=%d\09y7=%d\09z7=%d\0A\00"
@.str.17 = [34 x i8] c"P8: niekre\C5\9Blono wp\C3\B3\C5\82rz\C4\99dnych\0A\00"
@.str.18 = [23 x i8] c"P8: x8=%d\09y8=%d\09z8=%d\0A\00"
@.str.19 = [52 x i8] c"podane warto\C5\9Bci: val1=%d val2=%d val3=%d val4=%d \0A\00"
@.str.20 = [52 x i8] c"podane warto\C5\9Bci: val5=%d val6=%d val7=%d val8=%d \0A\00"
@.str.21 = [7 x i8] c"Menu:\0A\00"
@.str.22 = [68 x i8] c"1. podaj wsp\C3\B3\C5\82rz\C4\99dne wierzcho\C5\82ka P1 sze\C5\9Bcianu - dolna \C5\9Bciana\0A\00"
@.str.23 = [68 x i8] c"2. podaj wsp\C3\B3\C5\82rz\C4\99dne wierzcho\C5\82ka P2 sze\C5\9Bcianu - dolna \C5\9Bciana\0A\00"
@.str.24 = [68 x i8] c"3. podaj wsp\C3\B3\C5\82rz\C4\99dne wierzcho\C5\82ka P3 sze\C5\9Bcianu - dolna \C5\9Bciana\0A\00"
@.str.25 = [68 x i8] c"4. podaj wsp\C3\B3\C5\82rz\C4\99dne wierzcho\C5\82ka P4 sze\C5\9Bcianu - dolna \C5\9Bciana\0A\00"
@.str.26 = [69 x i8] c"5. podaj wsp\C3\B3\C5\82rz\C4\99dne wierzcho\C5\82ka P5 sze\C5\9Bcianu - g\C3\B3rna \C5\9Bciana\0A\00"
@.str.27 = [69 x i8] c"6. podaj wsp\C3\B3\C5\82rz\C4\99dne wierzcho\C5\82ka P6 sze\C5\9Bcianu - g\C3\B3rna \C5\9Bciana\0A\00"
@.str.28 = [69 x i8] c"7. podaj wsp\C3\B3\C5\82rz\C4\99dne wierzcho\C5\82ka P7 sze\C5\9Bcianu - g\C3\B3rna \C5\9Bciana\0A\00"
@.str.29 = [69 x i8] c"8. podaj wsp\C3\B3\C5\82rz\C4\99dne wierzcho\C5\82ka P8 sze\C5\9Bcianu - g\C3\B3rna \C5\9Bciana\0A\00"
@.str.30 = [29 x i8] c"9. czytaj okre\C5\9Blone punkty\0A\00"
@.str.31 = [39 x i8] c"10. podaj 8 warto\C5\9Bci z zakresu 0-255\0A\00"
@.str.32 = [42 x i8] c"11. zapisz warto\C5\9Bci w podanych punktach\0A\00"
@.str.33 = [11 x i8] c"0. koniec\0A\00"
@.str.34 = [3 x i8] c"%d\00"
@.str.35 = [4 x i8] c"x1=\00"
@.str.36 = [4 x i8] c" %d\00"
@.str.37 = [4 x i8] c"y1=\00"
@.str.38 = [4 x i8] c"z1=\00"
@.str.39 = [20 x i8] c"P1: poza zakresem!\0A\00"
@.str.40 = [4 x i8] c"x2=\00"
@.str.41 = [4 x i8] c"y2=\00"
@.str.42 = [4 x i8] c"z2=\00"
@.str.43 = [20 x i8] c"P2: poza zakresem!\0A\00"
@.str.44 = [4 x i8] c"x3=\00"
@.str.45 = [4 x i8] c"y3=\00"
@.str.46 = [4 x i8] c"z3=\00"
@.str.47 = [20 x i8] c"P3: poza zakresem!\0A\00"
@.str.48 = [4 x i8] c"x4=\00"
@.str.49 = [4 x i8] c"y4=\00"
@.str.50 = [4 x i8] c"z4=\00"
@.str.51 = [20 x i8] c"P4: poza zakresem!\0A\00"
@.str.52 = [4 x i8] c"x5=\00"
@.str.53 = [4 x i8] c"y5=\00"
@.str.54 = [4 x i8] c"z5=\00"
@.str.55 = [20 x i8] c"P5: poza zakresem!\0A\00"
@.str.56 = [4 x i8] c"x6=\00"
@.str.57 = [4 x i8] c"y6=\00"
@.str.58 = [4 x i8] c"z6=\00"
@.str.59 = [20 x i8] c"P6: poza zakresem!\0A\00"
@.str.60 = [4 x i8] c"x7=\00"
@.str.61 = [4 x i8] c"y7=\00"
@.str.62 = [4 x i8] c"z7=\00"
@.str.63 = [20 x i8] c"P7: poza zakresem!\0A\00"
@.str.64 = [4 x i8] c"x8=\00"
@.str.65 = [4 x i8] c"y8=\00"
@.str.66 = [4 x i8] c"z8=\00"
@.str.67 = [20 x i8] c"P8: poza zakresem!\0A\00"
@.str.68 = [22 x i8] c"<c1> P1(%d,%d,%d)=%d\0A\00"
@.str.69 = [22 x i8] c"<c2> P1(%d,%d,%d)=%d\0A\00"
@.str.70 = [22 x i8] c"<c3> P1(%d,%d,%d)=%d\0A\00"
@.str.71 = [22 x i8] c"<c1> P2(%d,%d,%d)=%d\0A\00"
@.str.72 = [22 x i8] c"<c2> P2(%d,%d,%d)=%d\0A\00"
@.str.73 = [22 x i8] c"<c3> P2(%d,%d,%d)=%d\0A\00"
@.str.74 = [22 x i8] c"<c1> P3(%d,%d,%d)=%d\0A\00"
@.str.75 = [22 x i8] c"<c2> P3(%d,%d,%d)=%d\0A\00"
@.str.76 = [22 x i8] c"<c3> P3(%d,%d,%d)=%d\0A\00"
@.str.77 = [22 x i8] c"<c1> P4(%d,%d,%d)=%d\0A\00"
@.str.78 = [22 x i8] c"<c2> P4(%d,%d,%d)=%d\0A\00"
@.str.79 = [22 x i8] c"<c3> P4(%d,%d,%d)=%d\0A\00"
@.str.80 = [22 x i8] c"<c1> P5(%d,%d,%d)=%d\0A\00"
@.str.81 = [22 x i8] c"<c2> P5(%d,%d,%d)=%d\0A\00"
@.str.82 = [22 x i8] c"<c3> P5(%d,%d,%d)=%d\0A\00"
@.str.83 = [22 x i8] c"<c1> P6(%d,%d,%d)=%d\0A\00"
@.str.84 = [22 x i8] c"<c2> P6(%d,%d,%d)=%d\0A\00"
@.str.85 = [22 x i8] c"<c3> P6(%d,%d,%d)=%d\0A\00"
@.str.86 = [22 x i8] c"<c1> P7(%d,%d,%d)=%d\0A\00"
@.str.87 = [22 x i8] c"<c2> P7(%d,%d,%d)=%d\0A\00"
@.str.88 = [22 x i8] c"<c3> P7(%d,%d,%d)=%d\0A\00"
@.str.89 = [22 x i8] c"<c1> P8(%d,%d,%d)=%d\0A\00"
@.str.90 = [22 x i8] c"<c2> P8(%d,%d,%d)=%d\0A\00"
@.str.91 = [22 x i8] c"<c3> P8(%d,%d,%d)=%d\0A\00"
@.str.92 = [11 x i8] c"hit enter\0A\00"
@.str.93 = [3 x i8] c"%s\00"
@.str.94 = [41 x i8] c"podaj 8 warto\C5\9Bci z przedzia\C5\82u <0,255>\0A\00"
@.str.95 = [25 x i8] c"\0Awarto\C5\9B\C4\87 val1 dla P1:\0A\00"
@.str.96 = [25 x i8] c"\0Awarto\C5\9B\C4\87 val2 dla P2:\0A\00"
@.str.97 = [25 x i8] c"\0Awarto\C5\9B\C4\87 val3 dla P3:\0A\00"
@.str.98 = [25 x i8] c"\0Awarto\C5\9B\C4\87 val4 dla P4:\0A\00"
@.str.99 = [25 x i8] c"\0Awarto\C5\9B\C4\87 val5 dla P5:\0A\00"
@.str.100 = [25 x i8] c"\0Awarto\C5\9B\C4\87 val6 dla P6:\0A\00"
@.str.101 = [25 x i8] c"\0Awarto\C5\9B\C4\87 val7 dla P7:\0A\00"
@.str.102 = [25 x i8] c"\0Awarto\C5\9B\C4\87 val8 dla P8:\0A\00"
@.str.103 = [13 x i8] c"mem cleared\0A\00"
@.str.104 = [16 x i8] c"ctrl+c to quit\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 447, i32* %7
%62 = load i32, i32* %7
%63 = load i32, i32* %7
%64 = mul nsw i32 %62, %63
%65 = load i32, i32* %7
%66 = mul nsw i32 %64, %65
%67 = mul nsw i32 %66, 2
%68 = sub nsw i32 %67, 1
store i32 %68, i32* %8
%69 = load i32, i32* %8
%70 = sext i32 %69 to i64
%71 = mul i64 1, %70
%72 = trunc i64 %71 to i32
%73 = call i8* @malloc(i32 %72)
store i8* %73, i8** %9
%74 = load i32, i32* %8
%75 = sext i32 %74 to i64
%76 = mul i64 1, %75
%77 = trunc i64 %76 to i32
%78 = call i8* @malloc(i32 %77)
store i8* %78, i8** %10
%79 = load i32, i32* %8
%80 = sext i32 %79 to i64
%81 = mul i64 1, %80
%82 = trunc i64 %81 to i32
%83 = call i8* @malloc(i32 %82)
store i8* %83, i8** %11
store i32 0, i32* %6
br label %84
84: ; preds = %101, %2
%85 = load i32, i32* %6
%86 = load i32, i32* %8
%87 = icmp slt i32 %85, %86
br i1 %87, label %88, label %104
88: ; preds = %84
%89 = load i8*, i8** %9
%90 = load i32, i32* %6
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %89, i64 %91
store i8 10, i8* %92
%93 = load i8*, i8** %10
%94 = load i32, i32* %6
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i8, i8* %93, i64 %95
store i8 20, i8* %96
%97 = load i8*, i8** %11
%98 = load i32, i32* %6
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %97, i64 %99
store i8 30, i8* %100
br label %101
101: ; preds = %88
%102 = load i32, i32* %6
%103 = add nsw i32 %102, 1
store i32 %103, i32* %6
br label %84
104: ; preds = %84
%105 = load i32, i32* %6
%106 = load i32, i32* %8
%107 = icmp eq i32 %105, %106
br i1 %107, label %108, label %116
108: ; preds = %104
%109 = load i32, i32* %8
%110 = load i32, i32* %8
%111 = add nsw i32 %110, 1
%112 = sdiv i32 %111, 1024
%113 = sdiv i32 %112, 1024
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0), i32 %109, i32 %113)
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.1, i64 0, i64 0))
br label %116
116: ; preds = %108, %104
%117 = call i32 @sleep(i32 5)
store i32 810, i32* %12
store i32 0, i32* %13
store i32 269, i32* %14
store i32 270, i32* %15
store i32 539, i32* %16
store i32 540, i32* %17
store i32 809, i32* %18
%118 = load i32, i32* %7
%119 = sub nsw i32 811, %118
store i32 %119, i32* %19
store i32 -1, i32* %20
store i32 -1, i32* %21
store i32 -1, i32* %22
store i32 -1, i32* %23
store i32 -1, i32* %24
store i32 -1, i32* %25
store i32 -1, i32* %26
store i32 -1, i32* %27
store i32 -1, i32* %28
store i32 -1, i32* %29
store i32 -1, i32* %30
store i32 -1, i32* %31
store i32 -1, i32* %32
store i32 -1, i32* %33
store i32 -1, i32* %34
store i32 -1, i32* %35
store i32 -1, i32* %36
store i32 -1, i32* %37
store i32 -1, i32* %38
store i32 -1, i32* %39
store i32 -1, i32* %40
store i32 -1, i32* %41
store i32 -1, i32* %42
store i32 -1, i32* %43
store i32 0, i32* %44
store i32 0, i32* %45
store i32 0, i32* %46
store i32 0, i32* %47
store i32 0, i32* %48
store i32 0, i32* %49
store i32 0, i32* %50
store i32 0, i32* %51
store i32 -1, i32* %52
store i32 -1, i32* %53
store i32 -1, i32* %54
store i32 -1, i32* %55
store i32 -1, i32* %56
store i32 -1, i32* %57
store i32 -1, i32* %58
store i32 -1, i32* %59
store i32 0, i32* %60
store i32 0, i32* %61
br label %120
120: ; preds = %1826, %1825, %116
%121 = load i32, i32* %61
%122 = icmp eq i32 %121, 0
br i1 %122, label %123, label %1827
123: ; preds = %120
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
%125 = load i32, i32* %20
%126 = icmp slt i32 %125, 0
br i1 %126, label %145, label %127
127: ; preds = %123
%128 = load i32, i32* %20
%129 = load i32, i32* %12
%130 = icmp sgt i32 %128, %129
br i1 %130, label %145, label %131
131: ; preds = %127
%132 = load i32, i32* %21
%133 = icmp slt i32 %132, 0
br i1 %133, label %145, label %134
134: ; preds = %131
%135 = load i32, i32* %21
%136 = load i32, i32* %12
%137 = icmp sgt i32 %135, %136
br i1 %137, label %145, label %138
138: ; preds = %134
%139 = load i32, i32* %22
%140 = icmp slt i32 %139, 0
br i1 %140, label %145, label %141
141: ; preds = %138
%142 = load i32, i32* %22
%143 = load i32, i32* %12
%144 = icmp sgt i32 %142, %143
br i1 %144, label %145, label %147
145: ; preds = %141, %138, %134, %131, %127, %123
%146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %44
br label %152
147: ; preds = %141
%148 = load i32, i32* %20
%149 = load i32, i32* %21
%150 = load i32, i32* %22
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0), i32 %148, i32 %149, i32 %150)
store i32 1, i32* %44
br label %152
152: ; preds = %147, %145
%153 = load i32, i32* %23
%154 = icmp slt i32 %153, 0
br i1 %154, label %173, label %155
155: ; preds = %152
%156 = load i32, i32* %23
%157 = load i32, i32* %12
%158 = icmp sgt i32 %156, %157
br i1 %158, label %173, label %159
159: ; preds = %155
%160 = load i32, i32* %24
%161 = icmp slt i32 %160, 0
br i1 %161, label %173, label %162
162: ; preds = %159
%163 = load i32, i32* %24
%164 = load i32, i32* %12
%165 = icmp sgt i32 %163, %164
br i1 %165, label %173, label %166
166: ; preds = %162
%167 = load i32, i32* %25
%168 = icmp slt i32 %167, 0
br i1 %168, label %173, label %169
169: ; preds = %166
%170 = load i32, i32* %25
%171 = load i32, i32* %12
%172 = icmp sgt i32 %170, %171
br i1 %172, label %173, label %175
173: ; preds = %169, %166, %162, %159, %155, %152
%174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.5, i64 0, i64 0))
store i32 0, i32* %45
br label %180
175: ; preds = %169
%176 = load i32, i32* %23
%177 = load i32, i32* %24
%178 = load i32, i32* %25
%179 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %176, i32 %177, i32 %178)
store i32 1, i32* %45
br label %180
180: ; preds = %175, %173
%181 = load i32, i32* %26
%182 = icmp slt i32 %181, 0
br i1 %182, label %201, label %183
183: ; preds = %180
%184 = load i32, i32* %26
%185 = load i32, i32* %12
%186 = icmp sgt i32 %184, %185
br i1 %186, label %201, label %187
187: ; preds = %183
%188 = load i32, i32* %27
%189 = icmp slt i32 %188, 0
br i1 %189, label %201, label %190
190: ; preds = %187
%191 = load i32, i32* %27
%192 = load i32, i32* %12
%193 = icmp sgt i32 %191, %192
br i1 %193, label %201, label %194
194: ; preds = %190
%195 = load i32, i32* %28
%196 = icmp slt i32 %195, 0
br i1 %196, label %201, label %197
197: ; preds = %194
%198 = load i32, i32* %28
%199 = load i32, i32* %12
%200 = icmp sgt i32 %198, %199
br i1 %200, label %201, label %203
201: ; preds = %197, %194, %190, %187, %183, %180
%202 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %46
br label %208
203: ; preds = %197
%204 = load i32, i32* %26
%205 = load i32, i32* %27
%206 = load i32, i32* %28
%207 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.8, i64 0, i64 0), i32 %204, i32 %205, i32 %206)
store i32 1, i32* %46
br label %208
208: ; preds = %203, %201
%209 = load i32, i32* %29
%210 = icmp slt i32 %209, 0
br i1 %210, label %229, label %211
211: ; preds = %208
%212 = load i32, i32* %29
%213 = load i32, i32* %12
%214 = icmp sgt i32 %212, %213
br i1 %214, label %229, label %215
215: ; preds = %211
%216 = load i32, i32* %30
%217 = icmp slt i32 %216, 0
br i1 %217, label %229, label %218
218: ; preds = %215
%219 = load i32, i32* %30
%220 = load i32, i32* %12
%221 = icmp sgt i32 %219, %220
br i1 %221, label %229, label %222
222: ; preds = %218
%223 = load i32, i32* %31
%224 = icmp slt i32 %223, 0
br i1 %224, label %229, label %225
225: ; preds = %222
%226 = load i32, i32* %31
%227 = load i32, i32* %12
%228 = icmp sgt i32 %226, %227
br i1 %228, label %229, label %231
229: ; preds = %225, %222, %218, %215, %211, %208
%230 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %47
br label %236
231: ; preds = %225
%232 = load i32, i32* %29
%233 = load i32, i32* %30
%234 = load i32, i32* %31
%235 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.10, i64 0, i64 0), i32 %232, i32 %233, i32 %234)
store i32 1, i32* %47
br label %236
236: ; preds = %231, %229
%237 = load i32, i32* %32
%238 = icmp slt i32 %237, 0
br i1 %238, label %257, label %239
239: ; preds = %236
%240 = load i32, i32* %32
%241 = load i32, i32* %12
%242 = icmp sgt i32 %240, %241
br i1 %242, label %257, label %243
243: ; preds = %239
%244 = load i32, i32* %33
%245 = icmp slt i32 %244, 0
br i1 %245, label %257, label %246
246: ; preds = %243
%247 = load i32, i32* %33
%248 = load i32, i32* %12
%249 = icmp sgt i32 %247, %248
br i1 %249, label %257, label %250
250: ; preds = %246
%251 = load i32, i32* %34
%252 = icmp slt i32 %251, 0
br i1 %252, label %257, label %253
253: ; preds = %250
%254 = load i32, i32* %34
%255 = load i32, i32* %12
%256 = icmp sgt i32 %254, %255
br i1 %256, label %257, label %259
257: ; preds = %253, %250, %246, %243, %239, %236
%258 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.11, i64 0, i64 0))
store i32 0, i32* %48
br label %264
259: ; preds = %253
%260 = load i32, i32* %32
%261 = load i32, i32* %33
%262 = load i32, i32* %34
%263 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.12, i64 0, i64 0), i32 %260, i32 %261, i32 %262)
store i32 1, i32* %48
br label %264
264: ; preds = %259, %257
%265 = load i32, i32* %35
%266 = icmp slt i32 %265, 0
br i1 %266, label %285, label %267
267: ; preds = %264
%268 = load i32, i32* %35
%269 = load i32, i32* %12
%270 = icmp sgt i32 %268, %269
br i1 %270, label %285, label %271
271: ; preds = %267
%272 = load i32, i32* %36
%273 = icmp slt i32 %272, 0
br i1 %273, label %285, label %274
274: ; preds = %271
%275 = load i32, i32* %36
%276 = load i32, i32* %12
%277 = icmp sgt i32 %275, %276
br i1 %277, label %285, label %278
278: ; preds = %274
%279 = load i32, i32* %37
%280 = icmp slt i32 %279, 0
br i1 %280, label %285, label %281
281: ; preds = %278
%282 = load i32, i32* %37
%283 = load i32, i32* %12
%284 = icmp sgt i32 %282, %283
br i1 %284, label %285, label %287
285: ; preds = %281, %278, %274, %271, %267, %264
%286 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.13, i64 0, i64 0))
store i32 0, i32* %49
br label %292
287: ; preds = %281
%288 = load i32, i32* %35
%289 = load i32, i32* %36
%290 = load i32, i32* %37
%291 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.14, i64 0, i64 0), i32 %288, i32 %289, i32 %290)
store i32 1, i32* %49
br label %292
292: ; preds = %287, %285
%293 = load i32, i32* %38
%294 = icmp slt i32 %293, 0
br i1 %294, label %313, label %295
295: ; preds = %292
%296 = load i32, i32* %38
%297 = load i32, i32* %12
%298 = icmp sgt i32 %296, %297
br i1 %298, label %313, label %299
299: ; preds = %295
%300 = load i32, i32* %39
%301 = icmp slt i32 %300, 0
br i1 %301, label %313, label %302
302: ; preds = %299
%303 = load i32, i32* %39
%304 = load i32, i32* %12
%305 = icmp sgt i32 %303, %304
br i1 %305, label %313, label %306
306: ; preds = %302
%307 = load i32, i32* %40
%308 = icmp slt i32 %307, 0
br i1 %308, label %313, label %309
309: ; preds = %306
%310 = load i32, i32* %31
%311 = load i32, i32* %12
%312 = icmp sgt i32 %310, %311
br i1 %312, label %313, label %315
313: ; preds = %309, %306, %302, %299, %295, %292
%314 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.15, i64 0, i64 0))
store i32 0, i32* %50
br label %320
315: ; preds = %309
%316 = load i32, i32* %38
%317 = load i32, i32* %39
%318 = load i32, i32* %40
%319 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.16, i64 0, i64 0), i32 %316, i32 %317, i32 %318)
store i32 1, i32* %50
br label %320
320: ; preds = %315, %313
%321 = load i32, i32* %41
%322 = icmp slt i32 %321, 0
br i1 %322, label %341, label %323
323: ; preds = %320
%324 = load i32, i32* %41
%325 = load i32, i32* %12
%326 = icmp sgt i32 %324, %325
br i1 %326, label %341, label %327
327: ; preds = %323
%328 = load i32, i32* %42
%329 = icmp slt i32 %328, 0
br i1 %329, label %341, label %330
330: ; preds = %327
%331 = load i32, i32* %42
%332 = load i32, i32* %12
%333 = icmp sgt i32 %331, %332
br i1 %333, label %341, label %334
334: ; preds = %330
%335 = load i32, i32* %43
%336 = icmp slt i32 %335, 0
br i1 %336, label %341, label %337
337: ; preds = %334
%338 = load i32, i32* %43
%339 = load i32, i32* %12
%340 = icmp sgt i32 %338, %339
br i1 %340, label %341, label %343
341: ; preds = %337, %334, %330, %327, %323, %320
%342 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.17, i64 0, i64 0))
store i32 0, i32* %51
br label %348
343: ; preds = %337
%344 = load i32, i32* %41
%345 = load i32, i32* %42
%346 = load i32, i32* %43
%347 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.18, i64 0, i64 0), i32 %344, i32 %345, i32 %346)
store i32 1, i32* %51
br label %348
348: ; preds = %343, %341
%349 = load i32, i32* %52
%350 = icmp sle i32 0, %349
br i1 %350, label %351, label %407
351: ; preds = %348
%352 = load i32, i32* %52
%353 = icmp sle i32 %352, 255
br i1 %353, label %354, label %407
354: ; preds = %351
%355 = load i32, i32* %53
%356 = icmp sle i32 0, %355
br i1 %356, label %357, label %407
357: ; preds = %354
%358 = load i32, i32* %53
%359 = icmp sle i32 %358, 255
br i1 %359, label %360, label %407
360: ; preds = %357
%361 = load i32, i32* %54
%362 = icmp sle i32 0, %361
br i1 %362, label %363, label %407
363: ; preds = %360
%364 = load i32, i32* %54
%365 = icmp sle i32 %364, 255
br i1 %365, label %366, label %407
366: ; preds = %363
%367 = load i32, i32* %55
%368 = icmp sle i32 0, %367
br i1 %368, label %369, label %407
369: ; preds = %366
%370 = load i32, i32* %55
%371 = icmp sle i32 %370, 255
br i1 %371, label %372, label %407
372: ; preds = %369
%373 = load i32, i32* %56
%374 = icmp sle i32 0, %373
br i1 %374, label %375, label %407
375: ; preds = %372
%376 = load i32, i32* %56
%377 = icmp sle i32 %376, 255
br i1 %377, label %378, label %407
378: ; preds = %375
%379 = load i32, i32* %57
%380 = icmp sle i32 0, %379
br i1 %380, label %381, label %407
381: ; preds = %378
%382 = load i32, i32* %57
%383 = icmp sle i32 %382, 255
br i1 %383, label %384, label %407
384: ; preds = %381
%385 = load i32, i32* %58
%386 = icmp sle i32 0, %385
br i1 %386, label %387, label %407
387: ; preds = %384
%388 = load i32, i32* %58
%389 = icmp sle i32 %388, 255
br i1 %389, label %390, label %407
390: ; preds = %387
%391 = load i32, i32* %59
%392 = icmp sle i32 0, %391
br i1 %392, label %393, label %407
393: ; preds = %390
%394 = load i32, i32* %59
%395 = icmp sle i32 %394, 255
br i1 %395, label %396, label %407
396: ; preds = %393
%397 = load i32, i32* %52
%398 = load i32, i32* %53
%399 = load i32, i32* %54
%400 = load i32, i32* %55
%401 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.19, i64 0, i64 0), i32 %397, i32 %398, i32 %399, i32 %400)
%402 = load i32, i32* %56
%403 = load i32, i32* %57
%404 = load i32, i32* %58
%405 = load i32, i32* %59
%406 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.20, i64 0, i64 0), i32 %402, i32 %403, i32 %404, i32 %405)
br label %407
407: ; preds = %396, %393, %390, %387, %384, %381, %378, %375, %372, %369, %366, %363, %360, %357, %354, %351, %348
%408 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i64 0, i64 0))
%409 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.22, i64 0, i64 0))
%410 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.23, i64 0, i64 0))
%411 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.24, i64 0, i64 0))
%412 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.25, i64 0, i64 0))
%413 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.26, i64 0, i64 0))
%414 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.27, i64 0, i64 0))
%415 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.28, i64 0, i64 0))
%416 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.29, i64 0, i64 0))
%417 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.30, i64 0, i64 0))
%418 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.31, i64 0, i64 0))
%419 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.32, i64 0, i64 0))
%420 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.33, i64 0, i64 0))
%421 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.34, i64 0, i64 0), i32* %60)
%422 = load i32, i32* %60
switch i32 %422, label %1825 [
i32 1, label %423
i32 2, label %453
i32 3, label %483
i32 4, label %513
i32 5, label %543
i32 6, label %573
i32 7, label %603
i32 8, label %633
i32 9, label %663
i32 10, label %1248
i32 11, label %1328
i32 0, label %1817
]
423: ; preds = %407
%424 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.35, i64 0, i64 0))
%425 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %20)
%426 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.37, i64 0, i64 0))
%427 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %21)
%428 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.38, i64 0, i64 0))
%429 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %22)
%430 = load i32, i32* %20
%431 = icmp slt i32 %430, 0
br i1 %431, label %450, label %432
432: ; preds = %423
%433 = load i32, i32* %20
%434 = load i32, i32* %12
%435 = icmp sgt i32 %433, %434
br i1 %435, label %450, label %436
436: ; preds = %432
%437 = load i32, i32* %21
%438 = icmp slt i32 %437, 0
br i1 %438, label %450, label %439
439: ; preds = %436
%440 = load i32, i32* %21
%441 = load i32, i32* %12
%442 = icmp sgt i32 %440, %441
br i1 %442, label %450, label %443
443: ; preds = %439
%444 = load i32, i32* %22
%445 = icmp slt i32 %444, 0
br i1 %445, label %450, label %446
446: ; preds = %443
%447 = load i32, i32* %22
%448 = load i32, i32* %12
%449 = icmp sgt i32 %447, %448
br i1 %449, label %450, label %452
450: ; preds = %446, %443, %439, %436, %432, %423
%451 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.39, i64 0, i64 0))
store i32 -1, i32* %20
store i32 -1, i32* %21
store i32 -1, i32* %22
br label %1826
452: ; preds = %446
br label %1826
453: ; preds = %407
%454 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.40, i64 0, i64 0))
%455 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %23)
%456 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.41, i64 0, i64 0))
%457 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %24)
%458 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.42, i64 0, i64 0))
%459 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %25)
%460 = load i32, i32* %23
%461 = icmp slt i32 %460, 0
br i1 %461, label %480, label %462
462: ; preds = %453
%463 = load i32, i32* %23
%464 = load i32, i32* %12
%465 = icmp sgt i32 %463, %464
br i1 %465, label %480, label %466
466: ; preds = %462
%467 = load i32, i32* %24
%468 = icmp slt i32 %467, 0
br i1 %468, label %480, label %469
469: ; preds = %466
%470 = load i32, i32* %24
%471 = load i32, i32* %12
%472 = icmp sgt i32 %470, %471
br i1 %472, label %480, label %473
473: ; preds = %469
%474 = load i32, i32* %25
%475 = icmp slt i32 %474, 0
br i1 %475, label %480, label %476
476: ; preds = %473
%477 = load i32, i32* %25
%478 = load i32, i32* %12
%479 = icmp sgt i32 %477, %478
br i1 %479, label %480, label %482
480: ; preds = %476, %473, %469, %466, %462, %453
%481 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.43, i64 0, i64 0))
store i32 -1, i32* %23
store i32 -1, i32* %24
store i32 -1, i32* %25
br label %1826
482: ; preds = %476
br label %1826
483: ; preds = %407
%484 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.44, i64 0, i64 0))
%485 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %26)
%486 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.45, i64 0, i64 0))
%487 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %27)
%488 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.46, i64 0, i64 0))
%489 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %28)
%490 = load i32, i32* %26
%491 = icmp slt i32 %490, 0
br i1 %491, label %510, label %492
492: ; preds = %483
%493 = load i32, i32* %26
%494 = load i32, i32* %12
%495 = icmp sgt i32 %493, %494
br i1 %495, label %510, label %496
496: ; preds = %492
%497 = load i32, i32* %27
%498 = icmp slt i32 %497, 0
br i1 %498, label %510, label %499
499: ; preds = %496
%500 = load i32, i32* %27
%501 = load i32, i32* %12
%502 = icmp sgt i32 %500, %501
br i1 %502, label %510, label %503
503: ; preds = %499
%504 = load i32, i32* %28
%505 = icmp slt i32 %504, 0
br i1 %505, label %510, label %506
506: ; preds = %503
%507 = load i32, i32* %28
%508 = load i32, i32* %12
%509 = icmp sgt i32 %507, %508
br i1 %509, label %510, label %512
510: ; preds = %506, %503, %499, %496, %492, %483
%511 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.47, i64 0, i64 0))
store i32 -1, i32* %26
store i32 -1, i32* %27
store i32 -1, i32* %28
br label %1826
512: ; preds = %506
br label %1826
513: ; preds = %407
%514 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.48, i64 0, i64 0))
%515 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %29)
%516 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.49, i64 0, i64 0))
%517 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %30)
%518 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.50, i64 0, i64 0))
%519 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %31)
%520 = load i32, i32* %29
%521 = icmp slt i32 %520, 0
br i1 %521, label %540, label %522
522: ; preds = %513
%523 = load i32, i32* %29
%524 = load i32, i32* %12
%525 = icmp sgt i32 %523, %524
br i1 %525, label %540, label %526
526: ; preds = %522
%527 = load i32, i32* %30
%528 = icmp slt i32 %527, 0
br i1 %528, label %540, label %529
529: ; preds = %526
%530 = load i32, i32* %30
%531 = load i32, i32* %12
%532 = icmp sgt i32 %530, %531
br i1 %532, label %540, label %533
533: ; preds = %529
%534 = load i32, i32* %31
%535 = icmp slt i32 %534, 0
br i1 %535, label %540, label %536
536: ; preds = %533
%537 = load i32, i32* %31
%538 = load i32, i32* %12
%539 = icmp sgt i32 %537, %538
br i1 %539, label %540, label %542
540: ; preds = %536, %533, %529, %526, %522, %513
%541 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.51, i64 0, i64 0))
store i32 -1, i32* %29
store i32 -1, i32* %30
store i32 -1, i32* %31
br label %1826
542: ; preds = %536
br label %1826
543: ; preds = %407
%544 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.52, i64 0, i64 0))
%545 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %32)
%546 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.53, i64 0, i64 0))
%547 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %33)
%548 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0))
%549 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %34)
%550 = load i32, i32* %32
%551 = icmp slt i32 %550, 0
br i1 %551, label %570, label %552
552: ; preds = %543
%553 = load i32, i32* %32
%554 = load i32, i32* %12
%555 = icmp sgt i32 %553, %554
br i1 %555, label %570, label %556
556: ; preds = %552
%557 = load i32, i32* %33
%558 = icmp slt i32 %557, 0
br i1 %558, label %570, label %559
559: ; preds = %556
%560 = load i32, i32* %33
%561 = load i32, i32* %12
%562 = icmp sgt i32 %560, %561
br i1 %562, label %570, label %563
563: ; preds = %559
%564 = load i32, i32* %34
%565 = icmp slt i32 %564, 0
br i1 %565, label %570, label %566
566: ; preds = %563
%567 = load i32, i32* %34
%568 = load i32, i32* %12
%569 = icmp sgt i32 %567, %568
br i1 %569, label %570, label %572
570: ; preds = %566, %563, %559, %556, %552, %543
%571 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.55, i64 0, i64 0))
store i32 -1, i32* %32
store i32 -1, i32* %33
store i32 -1, i32* %34
br label %1826
572: ; preds = %566
br label %1826
573: ; preds = %407
%574 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.56, i64 0, i64 0))
%575 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %35)
%576 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.57, i64 0, i64 0))
%577 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %36)
%578 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.58, i64 0, i64 0))
%579 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %37)
%580 = load i32, i32* %35
%581 = icmp slt i32 %580, 0
br i1 %581, label %600, label %582
582: ; preds = %573
%583 = load i32, i32* %35
%584 = load i32, i32* %12
%585 = icmp sgt i32 %583, %584
br i1 %585, label %600, label %586
586: ; preds = %582
%587 = load i32, i32* %36
%588 = icmp slt i32 %587, 0
br i1 %588, label %600, label %589
589: ; preds = %586
%590 = load i32, i32* %36
%591 = load i32, i32* %12
%592 = icmp sgt i32 %590, %591
br i1 %592, label %600, label %593
593: ; preds = %589
%594 = load i32, i32* %37
%595 = icmp slt i32 %594, 0
br i1 %595, label %600, label %596
596: ; preds = %593
%597 = load i32, i32* %31
%598 = load i32, i32* %12
%599 = icmp sgt i32 %597, %598
br i1 %599, label %600, label %602
600: ; preds = %596, %593, %589, %586, %582, %573
%601 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.59, i64 0, i64 0))
store i32 -1, i32* %35
store i32 -1, i32* %36
store i32 -1, i32* %37
br label %1826
602: ; preds = %596
br label %1826
603: ; preds = %407
%604 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.60, i64 0, i64 0))
%605 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %38)
%606 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.61, i64 0, i64 0))
%607 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %39)
%608 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.62, i64 0, i64 0))
%609 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %40)
%610 = load i32, i32* %38
%611 = icmp slt i32 %610, 0
br i1 %611, label %630, label %612
612: ; preds = %603
%613 = load i32, i32* %38
%614 = load i32, i32* %12
%615 = icmp sgt i32 %613, %614
br i1 %615, label %630, label %616
616: ; preds = %612
%617 = load i32, i32* %39
%618 = icmp slt i32 %617, 0
br i1 %618, label %630, label %619
619: ; preds = %616
%620 = load i32, i32* %39
%621 = load i32, i32* %12
%622 = icmp sgt i32 %620, %621
br i1 %622, label %630, label %623
623: ; preds = %619
%624 = load i32, i32* %40
%625 = icmp slt i32 %624, 0
br i1 %625, label %630, label %626
626: ; preds = %623
%627 = load i32, i32* %40
%628 = load i32, i32* %12
%629 = icmp sgt i32 %627, %628
br i1 %629, label %630, label %632
630: ; preds = %626, %623, %619, %616, %612, %603
%631 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.63, i64 0, i64 0))
store i32 -1, i32* %38
store i32 -1, i32* %39
store i32 -1, i32* %40
br label %1826
632: ; preds = %626
br label %1826
633: ; preds = %407
%634 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.64, i64 0, i64 0))
%635 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %41)
%636 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.65, i64 0, i64 0))
%637 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %42)
%638 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.66, i64 0, i64 0))
%639 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %43)
%640 = load i32, i32* %41
%641 = icmp slt i32 %640, 0
br i1 %641, label %660, label %642
642: ; preds = %633
%643 = load i32, i32* %41
%644 = load i32, i32* %12
%645 = icmp sgt i32 %643, %644
br i1 %645, label %660, label %646
646: ; preds = %642
%647 = load i32, i32* %42
%648 = icmp slt i32 %647, 0
br i1 %648, label %660, label %649
649: ; preds = %646
%650 = load i32, i32* %42
%651 = load i32, i32* %12
%652 = icmp sgt i32 %650, %651
br i1 %652, label %660, label %653
653: ; preds = %649
%654 = load i32, i32* %43
%655 = icmp slt i32 %654, 0
br i1 %655, label %660, label %656
656: ; preds = %653
%657 = load i32, i32* %43
%658 = load i32, i32* %12
%659 = icmp sgt i32 %657, %658
br i1 %659, label %660, label %662
660: ; preds = %656, %653, %649, %646, %642, %633
%661 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.67, i64 0, i64 0))
store i32 -1, i32* %41
store i32 -1, i32* %42
store i32 -1, i32* %43
br label %1826
662: ; preds = %656
br label %1826
663: ; preds = %407
%664 = load i32, i32* %44
%665 = icmp ne i32 %664, 0
br i1 %665, label %666, label %736
666: ; preds = %663
%667 = load i32, i32* %22
%668 = load i32, i32* %14
%669 = icmp sle i32 %667, %668
br i1 %669, label %670, label %685
670: ; preds = %666
%671 = load i32, i32* %20
%672 = load i32, i32* %21
%673 = load i32, i32* %22
%674 = load i8*, i8** %9
%675 = load i32, i32* %20
%676 = load i32, i32* %21
%677 = mul nsw i32 %675, %676
%678 = load i32, i32* %22
%679 = mul nsw i32 %677, %678
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds i8, i8* %674, i64 %680
%682 = load i8, i8* %681
%683 = sext i8 %682 to i32
%684 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.68, i64 0, i64 0), i32 %671, i32 %672, i32 %673, i32 %683)
br label %685
685: ; preds = %670, %666
%686 = load i32, i32* %22
%687 = load i32, i32* %15
%688 = icmp sge i32 %686, %687
br i1 %688, label %689, label %710
689: ; preds = %685
%690 = load i32, i32* %22
%691 = load i32, i32* %16
%692 = icmp sle i32 %690, %691
br i1 %692, label %693, label %710
693: ; preds = %689
%694 = load i32, i32* %20
%695 = load i32, i32* %21
%696 = load i32, i32* %22
%697 = load i8*, i8** %10
%698 = load i32, i32* %20
%699 = load i32, i32* %21
%700 = mul nsw i32 %698, %699
%701 = load i32, i32* %22
%702 = load i32, i32* %15
%703 = sub nsw i32 %701, %702
%704 = mul nsw i32 %700, %703
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds i8, i8* %697, i64 %705
%707 = load i8, i8* %706
%708 = sext i8 %707 to i32
%709 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.69, i64 0, i64 0), i32 %694, i32 %695, i32 %696, i32 %708)
br label %710
710: ; preds = %693, %689, %685
%711 = load i32, i32* %22
%712 = load i32, i32* %17
%713 = icmp sge i32 %711, %712
br i1 %713, label %714, label %735
714: ; preds = %710
%715 = load i32, i32* %22
%716 = load i32, i32* %18
%717 = icmp sle i32 %715, %716
br i1 %717, label %718, label %735
718: ; preds = %714
%719 = load i32, i32* %20
%720 = load i32, i32* %21
%721 = load i32, i32* %22
%722 = load i8*, i8** %11
%723 = load i32, i32* %20
%724 = load i32, i32* %21
%725 = mul nsw i32 %723, %724
%726 = load i32, i32* %22
%727 = load i32, i32* %17
%728 = sub nsw i32 %726, %727
%729 = mul nsw i32 %725, %728
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds i8, i8* %722, i64 %730
%732 = load i8, i8* %731
%733 = sext i8 %732 to i32
%734 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.70, i64 0, i64 0), i32 %719, i32 %720, i32 %721, i32 %733)
br label %735
735: ; preds = %718, %714, %710
br label %736
736: ; preds = %735, %663
%737 = load i32, i32* %45
%738 = icmp ne i32 %737, 0
br i1 %738, label %739, label %809
739: ; preds = %736
%740 = load i32, i32* %25
%741 = load i32, i32* %14
%742 = icmp sle i32 %740, %741
br i1 %742, label %743, label %758
743: ; preds = %739
%744 = load i32, i32* %23
%745 = load i32, i32* %24
%746 = load i32, i32* %25
%747 = load i8*, i8** %9
%748 = load i32, i32* %23
%749 = load i32, i32* %24
%750 = mul nsw i32 %748, %749
%751 = load i32, i32* %25
%752 = mul nsw i32 %750, %751
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds i8, i8* %747, i64 %753
%755 = load i8, i8* %754
%756 = sext i8 %755 to i32
%757 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.71, i64 0, i64 0), i32 %744, i32 %745, i32 %746, i32 %756)
br label %758
758: ; preds = %743, %739
%759 = load i32, i32* %25
%760 = load i32, i32* %15
%761 = icmp sge i32 %759, %760
br i1 %761, label %762, label %783
762: ; preds = %758
%763 = load i32, i32* %25
%764 = load i32, i32* %16
%765 = icmp sle i32 %763, %764
br i1 %765, label %766, label %783
766: ; preds = %762
%767 = load i32, i32* %23
%768 = load i32, i32* %24
%769 = load i32, i32* %25
%770 = load i8*, i8** %10
%771 = load i32, i32* %23
%772 = load i32, i32* %24
%773 = mul nsw i32 %771, %772
%774 = load i32, i32* %25
%775 = load i32, i32* %15
%776 = sub nsw i32 %774, %775
%777 = mul nsw i32 %773, %776
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds i8, i8* %770, i64 %778
%780 = load i8, i8* %779
%781 = sext i8 %780 to i32
%782 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.72, i64 0, i64 0), i32 %767, i32 %768, i32 %769, i32 %781)
br label %783
783: ; preds = %766, %762, %758
%784 = load i32, i32* %25
%785 = load i32, i32* %17
%786 = icmp sge i32 %784, %785
br i1 %786, label %787, label %808
787: ; preds = %783
%788 = load i32, i32* %25
%789 = load i32, i32* %18
%790 = icmp sle i32 %788, %789
br i1 %790, label %791, label %808
791: ; preds = %787
%792 = load i32, i32* %23
%793 = load i32, i32* %24
%794 = load i32, i32* %25
%795 = load i8*, i8** %11
%796 = load i32, i32* %23
%797 = load i32, i32* %24
%798 = mul nsw i32 %796, %797
%799 = load i32, i32* %25
%800 = load i32, i32* %17
%801 = sub nsw i32 %799, %800
%802 = mul nsw i32 %798, %801
%803 = sext i32 %802 to i64
%804 = getelementptr inbounds i8, i8* %795, i64 %803
%805 = load i8, i8* %804
%806 = sext i8 %805 to i32
%807 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.73, i64 0, i64 0), i32 %792, i32 %793, i32 %794, i32 %806)
br label %808
808: ; preds = %791, %787, %783
br label %809
809: ; preds = %808, %736
%810 = load i32, i32* %46
%811 = icmp ne i32 %810, 0
br i1 %811, label %812, label %882
812: ; preds = %809
%813 = load i32, i32* %28
%814 = load i32, i32* %14
%815 = icmp sle i32 %813, %814
br i1 %815, label %816, label %831
816: ; preds = %812
%817 = load i32, i32* %26
%818 = load i32, i32* %27
%819 = load i32, i32* %28
%820 = load i8*, i8** %9
%821 = load i32, i32* %26
%822 = load i32, i32* %27
%823 = mul nsw i32 %821, %822
%824 = load i32, i32* %28
%825 = mul nsw i32 %823, %824
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds i8, i8* %820, i64 %826
%828 = load i8, i8* %827
%829 = sext i8 %828 to i32
%830 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.74, i64 0, i64 0), i32 %817, i32 %818, i32 %819, i32 %829)
br label %831
831: ; preds = %816, %812
%832 = load i32, i32* %28
%833 = load i32, i32* %15
%834 = icmp sge i32 %832, %833
br i1 %834, label %835, label %856
835: ; preds = %831
%836 = load i32, i32* %28
%837 = load i32, i32* %16
%838 = icmp sle i32 %836, %837
br i1 %838, label %839, label %856
839: ; preds = %835
%840 = load i32, i32* %26
%841 = load i32, i32* %27
%842 = load i32, i32* %28
%843 = load i8*, i8** %10
%844 = load i32, i32* %26
%845 = load i32, i32* %27
%846 = mul nsw i32 %844, %845
%847 = load i32, i32* %28
%848 = load i32, i32* %15
%849 = sub nsw i32 %847, %848
%850 = mul nsw i32 %846, %849
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds i8, i8* %843, i64 %851
%853 = load i8, i8* %852
%854 = sext i8 %853 to i32
%855 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.75, i64 0, i64 0), i32 %840, i32 %841, i32 %842, i32 %854)
br label %856
856: ; preds = %839, %835, %831
%857 = load i32, i32* %28
%858 = load i32, i32* %17
%859 = icmp sge i32 %857, %858
br i1 %859, label %860, label %881
860: ; preds = %856
%861 = load i32, i32* %28
%862 = load i32, i32* %18
%863 = icmp sle i32 %861, %862
br i1 %863, label %864, label %881
864: ; preds = %860
%865 = load i32, i32* %26
%866 = load i32, i32* %27
%867 = load i32, i32* %28
%868 = load i8*, i8** %11
%869 = load i32, i32* %26
%870 = load i32, i32* %27
%871 = mul nsw i32 %869, %870
%872 = load i32, i32* %28
%873 = load i32, i32* %17
%874 = sub nsw i32 %872, %873
%875 = mul nsw i32 %871, %874
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds i8, i8* %868, i64 %876
%878 = load i8, i8* %877
%879 = sext i8 %878 to i32
%880 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.76, i64 0, i64 0), i32 %865, i32 %866, i32 %867, i32 %879)
br label %881
881: ; preds = %864, %860, %856
br label %882
882: ; preds = %881, %809
%883 = load i32, i32* %47
%884 = icmp ne i32 %883, 0
br i1 %884, label %885, label %955
885: ; preds = %882
%886 = load i32, i32* %31
%887 = load i32, i32* %14
%888 = icmp sle i32 %886, %887
br i1 %888, label %889, label %904
889: ; preds = %885
%890 = load i32, i32* %29
%891 = load i32, i32* %30
%892 = load i32, i32* %31
%893 = load i8*, i8** %9
%894 = load i32, i32* %29
%895 = load i32, i32* %30
%896 = mul nsw i32 %894, %895
%897 = load i32, i32* %31
%898 = mul nsw i32 %896, %897
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds i8, i8* %893, i64 %899
%901 = load i8, i8* %900
%902 = sext i8 %901 to i32
%903 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.77, i64 0, i64 0), i32 %890, i32 %891, i32 %892, i32 %902)
br label %904
904: ; preds = %889, %885
%905 = load i32, i32* %31
%906 = load i32, i32* %15
%907 = icmp sge i32 %905, %906
br i1 %907, label %908, label %929
908: ; preds = %904
%909 = load i32, i32* %31
%910 = load i32, i32* %16
%911 = icmp sle i32 %909, %910
br i1 %911, label %912, label %929
912: ; preds = %908
%913 = load i32, i32* %29
%914 = load i32, i32* %30
%915 = load i32, i32* %31
%916 = load i8*, i8** %10
%917 = load i32, i32* %29
%918 = load i32, i32* %30
%919 = mul nsw i32 %917, %918
%920 = load i32, i32* %31
%921 = load i32, i32* %15
%922 = sub nsw i32 %920, %921
%923 = mul nsw i32 %919, %922
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds i8, i8* %916, i64 %924
%926 = load i8, i8* %925
%927 = sext i8 %926 to i32
%928 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.78, i64 0, i64 0), i32 %913, i32 %914, i32 %915, i32 %927)
br label %929
929: ; preds = %912, %908, %904
%930 = load i32, i32* %31
%931 = load i32, i32* %17
%932 = icmp sge i32 %930, %931
br i1 %932, label %933, label %954
933: ; preds = %929
%934 = load i32, i32* %31
%935 = load i32, i32* %18
%936 = icmp sle i32 %934, %935
br i1 %936, label %937, label %954
937: ; preds = %933
%938 = load i32, i32* %29
%939 = load i32, i32* %30
%940 = load i32, i32* %31
%941 = load i8*, i8** %11
%942 = load i32, i32* %29
%943 = load i32, i32* %30
%944 = mul nsw i32 %942, %943
%945 = load i32, i32* %31
%946 = load i32, i32* %17
%947 = sub nsw i32 %945, %946
%948 = mul nsw i32 %944, %947
%949 = sext i32 %948 to i64
%950 = getelementptr inbounds i8, i8* %941, i64 %949
%951 = load i8, i8* %950
%952 = sext i8 %951 to i32
%953 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.79, i64 0, i64 0), i32 %938, i32 %939, i32 %940, i32 %952)
br label %954
954: ; preds = %937, %933, %929
br label %955
955: ; preds = %954, %882
%956 = load i32, i32* %48
%957 = icmp ne i32 %956, 0
br i1 %957, label %958, label %1028
958: ; preds = %955
%959 = load i32, i32* %34
%960 = load i32, i32* %14
%961 = icmp sle i32 %959, %960
br i1 %961, label %962, label %977
962: ; preds = %958
%963 = load i32, i32* %32
%964 = load i32, i32* %33
%965 = load i32, i32* %34
%966 = load i8*, i8** %9
%967 = load i32, i32* %32
%968 = load i32, i32* %33
%969 = mul nsw i32 %967, %968
%970 = load i32, i32* %34
%971 = mul nsw i32 %969, %970
%972 = sext i32 %971 to i64
%973 = getelementptr inbounds i8, i8* %966, i64 %972
%974 = load i8, i8* %973
%975 = sext i8 %974 to i32
%976 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.80, i64 0, i64 0), i32 %963, i32 %964, i32 %965, i32 %975)
br label %977
977: ; preds = %962, %958
%978 = load i32, i32* %34
%979 = load i32, i32* %15
%980 = icmp sge i32 %978, %979
br i1 %980, label %981, label %1002
981: ; preds = %977
%982 = load i32, i32* %34
%983 = load i32, i32* %16
%984 = icmp sle i32 %982, %983
br i1 %984, label %985, label %1002
985: ; preds = %981
%986 = load i32, i32* %32
%987 = load i32, i32* %33
%988 = load i32, i32* %34
%989 = load i8*, i8** %10
%990 = load i32, i32* %32
%991 = load i32, i32* %33
%992 = mul nsw i32 %990, %991
%993 = load i32, i32* %34
%994 = load i32, i32* %15
%995 = sub nsw i32 %993, %994
%996 = mul nsw i32 %992, %995
%997 = sext i32 %996 to i64
%998 = getelementptr inbounds i8, i8* %989, i64 %997
%999 = load i8, i8* %998
%1000 = sext i8 %999 to i32
%1001 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.81, i64 0, i64 0), i32 %986, i32 %987, i32 %988, i32 %1000)
br label %1002
1002: ; preds = %985, %981, %977
%1003 = load i32, i32* %34
%1004 = load i32, i32* %17
%1005 = icmp sge i32 %1003, %1004
br i1 %1005, label %1006, label %1027
1006: ; preds = %1002
%1007 = load i32, i32* %34
%1008 = load i32, i32* %18
%1009 = icmp sle i32 %1007, %1008
br i1 %1009, label %1010, label %1027
1010: ; preds = %1006
%1011 = load i32, i32* %32
%1012 = load i32, i32* %33
%1013 = load i32, i32* %34
%1014 = load i8*, i8** %11
%1015 = load i32, i32* %32
%1016 = load i32, i32* %33
%1017 = mul nsw i32 %1015, %1016
%1018 = load i32, i32* %34
%1019 = load i32, i32* %17
%1020 = sub nsw i32 %1018, %1019
%1021 = mul nsw i32 %1017, %1020
%1022 = sext i32 %1021 to i64
%1023 = getelementptr inbounds i8, i8* %1014, i64 %1022
%1024 = load i8, i8* %1023
%1025 = sext i8 %1024 to i32
%1026 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.82, i64 0, i64 0), i32 %1011, i32 %1012, i32 %1013, i32 %1025)
br label %1027
1027: ; preds = %1010, %1006, %1002
br label %1028
1028: ; preds = %1027, %955
%1029 = load i32, i32* %49
%1030 = icmp ne i32 %1029, 0
br i1 %1030, label %1031, label %1101
1031: ; preds = %1028
%1032 = load i32, i32* %37
%1033 = load i32, i32* %14
%1034 = icmp sle i32 %1032, %1033
br i1 %1034, label %1035, label %1050
1035: ; preds = %1031
%1036 = load i32, i32* %35
%1037 = load i32, i32* %36
%1038 = load i32, i32* %37
%1039 = load i8*, i8** %9
%1040 = load i32, i32* %35
%1041 = load i32, i32* %36
%1042 = mul nsw i32 %1040, %1041
%1043 = load i32, i32* %37
%1044 = mul nsw i32 %1042, %1043
%1045 = sext i32 %1044 to i64
%1046 = getelementptr inbounds i8, i8* %1039, i64 %1045
%1047 = load i8, i8* %1046
%1048 = sext i8 %1047 to i32
%1049 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.83, i64 0, i64 0), i32 %1036, i32 %1037, i32 %1038, i32 %1048)
br label %1050
1050: ; preds = %1035, %1031
%1051 = load i32, i32* %37
%1052 = load i32, i32* %15
%1053 = icmp sge i32 %1051, %1052
br i1 %1053, label %1054, label %1075
1054: ; preds = %1050
%1055 = load i32, i32* %37
%1056 = load i32, i32* %16
%1057 = icmp sle i32 %1055, %1056
br i1 %1057, label %1058, label %1075
1058: ; preds = %1054
%1059 = load i32, i32* %35
%1060 = load i32, i32* %36
%1061 = load i32, i32* %37
%1062 = load i8*, i8** %10
%1063 = load i32, i32* %35
%1064 = load i32, i32* %36
%1065 = mul nsw i32 %1063, %1064
%1066 = load i32, i32* %37
%1067 = load i32, i32* %15
%1068 = sub nsw i32 %1066, %1067
%1069 = mul nsw i32 %1065, %1068
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds i8, i8* %1062, i64 %1070
%1072 = load i8, i8* %1071
%1073 = sext i8 %1072 to i32
%1074 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.84, i64 0, i64 0), i32 %1059, i32 %1060, i32 %1061, i32 %1073)
br label %1075
1075: ; preds = %1058, %1054, %1050
%1076 = load i32, i32* %37
%1077 = load i32, i32* %17
%1078 = icmp sge i32 %1076, %1077
br i1 %1078, label %1079, label %1100
1079: ; preds = %1075
%1080 = load i32, i32* %37
%1081 = load i32, i32* %18
%1082 = icmp sle i32 %1080, %1081
br i1 %1082, label %1083, label %1100
1083: ; preds = %1079
%1084 = load i32, i32* %35
%1085 = load i32, i32* %36
%1086 = load i32, i32* %37
%1087 = load i8*, i8** %11
%1088 = load i32, i32* %35
%1089 = load i32, i32* %36
%1090 = mul nsw i32 %1088, %1089
%1091 = load i32, i32* %37
%1092 = load i32, i32* %17
%1093 = sub nsw i32 %1091, %1092
%1094 = mul nsw i32 %1090, %1093
%1095 = sext i32 %1094 to i64
%1096 = getelementptr inbounds i8, i8* %1087, i64 %1095
%1097 = load i8, i8* %1096
%1098 = sext i8 %1097 to i32
%1099 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.85, i64 0, i64 0), i32 %1084, i32 %1085, i32 %1086, i32 %1098)
br label %1100
1100: ; preds = %1083, %1079, %1075
br label %1101
1101: ; preds = %1100, %1028
%1102 = load i32, i32* %50
%1103 = icmp ne i32 %1102, 0
br i1 %1103, label %1104, label %1172
1104: ; preds = %1101
%1105 = load i32, i32* %40
%1106 = load i32, i32* %14
%1107 = icmp sle i32 %1105, %1106
br i1 %1107, label %1108, label %1123
1108: ; preds = %1104
%1109 = load i32, i32* %38
%1110 = load i32, i32* %39
%1111 = load i32, i32* %40
%1112 = load i8*, i8** %9
%1113 = load i32, i32* %38
%1114 = load i32, i32* %39
%1115 = mul nsw i32 %1113, %1114
%1116 = load i32, i32* %40
%1117 = mul nsw i32 %1115, %1116
%1118 = sext i32 %1117 to i64
%1119 = getelementptr inbounds i8, i8* %1112, i64 %1118
%1120 = load i8, i8* %1119
%1121 = sext i8 %1120 to i32
%1122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.86, i64 0, i64 0), i32 %1109, i32 %1110, i32 %1111, i32 %1121)
br label %1123
1123: ; preds = %1108, %1104
%1124 = load i32, i32* %40
%1125 = load i32, i32* %15
%1126 = icmp sge i32 %1124, %1125
br i1 %1126, label %1127, label %1147
1127: ; preds = %1123
%1128 = load i32, i32* %40
%1129 = load i32, i32* %16
%1130 = icmp sle i32 %1128, %1129
br i1 %1130, label %1131, label %1147
1131: ; preds = %1127
%1132 = load i32, i32* %38
%1133 = load i32, i32* %39
%1134 = load i32, i32* %40
%1135 = load i8*, i8** %10
%1136 = load i32, i32* %38
%1137 = load i32, i32* %39
%1138 = mul nsw i32 %1136, %1137
%1139 = load i32, i32* %40
%1140 = sub nsw i32 %1139, 620
%1141 = mul nsw i32 %1138, %1140
%1142 = sext i32 %1141 to i64
%1143 = getelementptr inbounds i8, i8* %1135, i64 %1142
%1144 = load i8, i8* %1143
%1145 = sext i8 %1144 to i32
%1146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.87, i64 0, i64 0), i32 %1132, i32 %1133, i32 %1134, i32 %1145)
br label %1147
1147: ; preds = %1131, %1127, %1123
%1148 = load i32, i32* %40
%1149 = load i32, i32* %17
%1150 = icmp sge i32 %1148, %1149
br i1 %1150, label %1151, label %1171
1151: ; preds = %1147
%1152 = load i32, i32* %40
%1153 = load i32, i32* %18
%1154 = icmp sle i32 %1152, %1153
br i1 %1154, label %1155, label %1171
1155: ; preds = %1151
%1156 = load i32, i32* %38
%1157 = load i32, i32* %39
%1158 = load i32, i32* %40
%1159 = load i8*, i8** %11
%1160 = load i32, i32* %38
%1161 = load i32, i32* %39
%1162 = mul nsw i32 %1160, %1161
%1163 = load i32, i32* %40
%1164 = sub nsw i32 %1163, 1240
%1165 = mul nsw i32 %1162, %1164
%1166 = sext i32 %1165 to i64
%1167 = getelementptr inbounds i8, i8* %1159, i64 %1166
%1168 = load i8, i8* %1167
%1169 = sext i8 %1168 to i32
%1170 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.88, i64 0, i64 0), i32 %1156, i32 %1157, i32 %1158, i32 %1169)
br label %1171
1171: ; preds = %1155, %1151, %1147
br label %1172
1172: ; preds = %1171, %1101
%1173 = load i32, i32* %51
%1174 = icmp ne i32 %1173, 0
br i1 %1174, label %1175, label %1245
1175: ; preds = %1172
%1176 = load i32, i32* %43
%1177 = load i32, i32* %14
%1178 = icmp sle i32 %1176, %1177
br i1 %1178, label %1179, label %1194
1179: ; preds = %1175
%1180 = load i32, i32* %41
%1181 = load i32, i32* %42
%1182 = load i32, i32* %43
%1183 = load i8*, i8** %9
%1184 = load i32, i32* %41
%1185 = load i32, i32* %42
%1186 = mul nsw i32 %1184, %1185
%1187 = load i32, i32* %43
%1188 = mul nsw i32 %1186, %1187
%1189 = sext i32 %1188 to i64
%1190 = getelementptr inbounds i8, i8* %1183, i64 %1189
%1191 = load i8, i8* %1190
%1192 = sext i8 %1191 to i32
%1193 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.89, i64 0, i64 0), i32 %1180, i32 %1181, i32 %1182, i32 %1192)
br label %1194
1194: ; preds = %1179, %1175
%1195 = load i32, i32* %43
%1196 = load i32, i32* %15
%1197 = icmp sge i32 %1195, %1196
br i1 %1197, label %1198, label %1219
1198: ; preds = %1194
%1199 = load i32, i32* %43
%1200 = load i32, i32* %16
%1201 = icmp sle i32 %1199, %1200
br i1 %1201, label %1202, label %1219
1202: ; preds = %1198
%1203 = load i32, i32* %41
%1204 = load i32, i32* %42
%1205 = load i32, i32* %43
%1206 = load i8*, i8** %10
%1207 = load i32, i32* %41
%1208 = load i32, i32* %42
%1209 = mul nsw i32 %1207, %1208
%1210 = load i32, i32* %43
%1211 = load i32, i32* %15
%1212 = sub nsw i32 %1210, %1211
%1213 = mul nsw i32 %1209, %1212
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds i8, i8* %1206, i64 %1214
%1216 = load i8, i8* %1215
%1217 = sext i8 %1216 to i32
%1218 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.90, i64 0, i64 0), i32 %1203, i32 %1204, i32 %1205, i32 %1217)
br label %1219
1219: ; preds = %1202, %1198, %1194
%1220 = load i32, i32* %43
%1221 = load i32, i32* %17
%1222 = icmp sge i32 %1220, %1221
br i1 %1222, label %1223, label %1244
1223: ; preds = %1219
%1224 = load i32, i32* %43
%1225 = load i32, i32* %18
%1226 = icmp sle i32 %1224, %1225
br i1 %1226, label %1227, label %1244
1227: ; preds = %1223
%1228 = load i32, i32* %41
%1229 = load i32, i32* %42
%1230 = load i32, i32* %43
%1231 = load i8*, i8** %11
%1232 = load i32, i32* %41
%1233 = load i32, i32* %42
%1234 = mul nsw i32 %1232, %1233
%1235 = load i32, i32* %43
%1236 = load i32, i32* %17
%1237 = sub nsw i32 %1235, %1236
%1238 = mul nsw i32 %1234, %1237
%1239 = sext i32 %1238 to i64
%1240 = getelementptr inbounds i8, i8* %1231, i64 %1239
%1241 = load i8, i8* %1240
%1242 = sext i8 %1241 to i32
%1243 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.91, i64 0, i64 0), i32 %1228, i32 %1229, i32 %1230, i32 %1242)
br label %1244
1244: ; preds = %1227, %1223, %1219
br label %1245
1245: ; preds = %1244, %1172
%1246 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.92, i64 0, i64 0))
%1247 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.93, i64 0, i64 0), i32* %6)
br label %1826
1248: ; preds = %407
%1249 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.94, i64 0, i64 0))
br label %1250
1250: ; preds = %1248, %1326
%1251 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.95, i64 0, i64 0))
%1252 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %52)
%1253 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.96, i64 0, i64 0))
%1254 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %53)
%1255 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.97, i64 0, i64 0))
%1256 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %54)
%1257 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.98, i64 0, i64 0))
%1258 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %55)
%1259 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.99, i64 0, i64 0))
%1260 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %56)
%1261 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.100, i64 0, i64 0))
%1262 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %57)
%1263 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.101, i64 0, i64 0))
%1264 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %58)
%1265 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.102, i64 0, i64 0))
%1266 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.36, i64 0, i64 0), i32* %59)
%1267 = load i32, i32* %52
%1268 = icmp sle i32 0, %1267
br i1 %1268, label %1269, label %1325
1269: ; preds = %1250
%1270 = load i32, i32* %52
%1271 = icmp sle i32 %1270, 255
br i1 %1271, label %1272, label %1325
1272: ; preds = %1269
%1273 = load i32, i32* %53
%1274 = icmp sle i32 0, %1273
br i1 %1274, label %1275, label %1325
1275: ; preds = %1272
%1276 = load i32, i32* %53
%1277 = icmp sle i32 %1276, 255
br i1 %1277, label %1278, label %1325
1278: ; preds = %1275
%1279 = load i32, i32* %54
%1280 = icmp sle i32 0, %1279
br i1 %1280, label %1281, label %1325
1281: ; preds = %1278
%1282 = load i32, i32* %54
%1283 = icmp sle i32 %1282, 255
br i1 %1283, label %1284, label %1325
1284: ; preds = %1281
%1285 = load i32, i32* %55
%1286 = icmp sle i32 0, %1285
br i1 %1286, label %1287, label %1325
1287: ; preds = %1284
%1288 = load i32, i32* %55
%1289 = icmp sle i32 %1288, 255
br i1 %1289, label %1290, label %1325
1290: ; preds = %1287
%1291 = load i32, i32* %56
%1292 = icmp sle i32 0, %1291
br i1 %1292, label %1293, label %1325
1293: ; preds = %1290
%1294 = load i32, i32* %56
%1295 = icmp sle i32 %1294, 255
br i1 %1295, label %1296, label %1325
1296: ; preds = %1293
%1297 = load i32, i32* %57
%1298 = icmp sle i32 0, %1297
br i1 %1298, label %1299, label %1325
1299: ; preds = %1296
%1300 = load i32, i32* %57
%1301 = icmp sle i32 %1300, 255
br i1 %1301, label %1302, label %1325
1302: ; preds = %1299
%1303 = load i32, i32* %58
%1304 = icmp sle i32 0, %1303
br i1 %1304, label %1305, label %1325
1305: ; preds = %1302
%1306 = load i32, i32* %58
%1307 = icmp sle i32 %1306, 255
br i1 %1307, label %1308, label %1325
1308: ; preds = %1305
%1309 = load i32, i32* %59
%1310 = icmp sle i32 0, %1309
br i1 %1310, label %1311, label %1325
1311: ; preds = %1308
%1312 = load i32, i32* %59
%1313 = icmp sle i32 %1312, 255
br i1 %1313, label %1314, label %1325
1314: ; preds = %1311
%1315 = load i32, i32* %52
%1316 = load i32, i32* %53
%1317 = load i32, i32* %54
%1318 = load i32, i32* %55
%1319 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.19, i64 0, i64 0), i32 %1315, i32 %1316, i32 %1317, i32 %1318)
%1320 = load i32, i32* %56
%1321 = load i32, i32* %57
%1322 = load i32, i32* %58
%1323 = load i32, i32* %59
%1324 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.20, i64 0, i64 0), i32 %1320, i32 %1321, i32 %1322, i32 %1323)
br label %1327
1325: ; preds = %1311, %1308, %1305, %1302, %1299, %1296, %1293, %1290, %1287, %1284, %1281, %1278, %1275, %1272, %1269, %1250
store i32 -1, i32* %52
store i32 -1, i32* %53
store i32 -1, i32* %54
store i32 -1, i32* %55
store i32 -1, i32* %56
store i32 -1, i32* %57
store i32 -1, i32* %58
store i32 -1, i32* %59
br label %1326
1326: ; preds = %1325
br label %1250
1327: ; preds = %1314
br label %1826
1328: ; preds = %407
%1329 = load i32, i32* %44
%1330 = icmp ne i32 %1329, 0
br i1 %1330, label %1331, label %1389
1331: ; preds = %1328
%1332 = load i32, i32* %22
%1333 = load i32, i32* %14
%1334 = icmp sle i32 %1332, %1333
br i1 %1334, label %1335, label %1346
1335: ; preds = %1331
%1336 = load i32, i32* %52
%1337 = trunc i32 %1336 to i8
%1338 = load i8*, i8** %9
%1339 = load i32, i32* %20
%1340 = load i32, i32* %21
%1341 = mul nsw i32 %1339, %1340
%1342 = load i32, i32* %22
%1343 = mul nsw i32 %1341, %1342
%1344 = sext i32 %1343 to i64
%1345 = getelementptr inbounds i8, i8* %1338, i64 %1344
store i8 %1337, i8* %1345
br label %1346
1346: ; preds = %1335, %1331
%1347 = load i32, i32* %22
%1348 = load i32, i32* %15
%1349 = icmp sge i32 %1347, %1348
br i1 %1349, label %1350, label %1367
1350: ; preds = %1346
%1351 = load i32, i32* %22
%1352 = load i32, i32* %16
%1353 = icmp sle i32 %1351, %1352
br i1 %1353, label %1354, label %1367
1354: ; preds = %1350
%1355 = load i32, i32* %52
%1356 = trunc i32 %1355 to i8
%1357 = load i8*, i8** %10
%1358 = load i32, i32* %20
%1359 = load i32, i32* %21
%1360 = mul nsw i32 %1358, %1359
%1361 = load i32, i32* %22
%1362 = load i32, i32* %15
%1363 = sub nsw i32 %1361, %1362
%1364 = mul nsw i32 %1360, %1363
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds i8, i8* %1357, i64 %1365
store i8 %1356, i8* %1366
br label %1367
1367: ; preds = %1354, %1350, %1346
%1368 = load i32, i32* %22
%1369 = load i32, i32* %17
%1370 = icmp sge i32 %1368, %1369
br i1 %1370, label %1371, label %1388
1371: ; preds = %1367
%1372 = load i32, i32* %22
%1373 = load i32, i32* %18
%1374 = icmp sle i32 %1372, %1373
br i1 %1374, label %1375, label %1388
1375: ; preds = %1371
%1376 = load i32, i32* %52
%1377 = trunc i32 %1376 to i8
%1378 = load i8*, i8** %11
%1379 = load i32, i32* %20
%1380 = load i32, i32* %21
%1381 = mul nsw i32 %1379, %1380
%1382 = load i32, i32* %22
%1383 = load i32, i32* %17
%1384 = sub nsw i32 %1382, %1383
%1385 = mul nsw i32 %1381, %1384
%1386 = sext i32 %1385 to i64
%1387 = getelementptr inbounds i8, i8* %1378, i64 %1386
store i8 %1377, i8* %1387
br label %1388
1388: ; preds = %1375, %1371, %1367
br label %1389
1389: ; preds = %1388, %1328
%1390 = load i32, i32* %45
%1391 = icmp ne i32 %1390, 0
br i1 %1391, label %1392, label %1450
1392: ; preds = %1389
%1393 = load i32, i32* %25
%1394 = load i32, i32* %14
%1395 = icmp sle i32 %1393, %1394
br i1 %1395, label %1396, label %1407
1396: ; preds = %1392
%1397 = load i32, i32* %53
%1398 = trunc i32 %1397 to i8
%1399 = load i8*, i8** %9
%1400 = load i32, i32* %23
%1401 = load i32, i32* %24
%1402 = mul nsw i32 %1400, %1401
%1403 = load i32, i32* %25
%1404 = mul nsw i32 %1402, %1403
%1405 = sext i32 %1404 to i64
%1406 = getelementptr inbounds i8, i8* %1399, i64 %1405
store i8 %1398, i8* %1406
br label %1407
1407: ; preds = %1396, %1392
%1408 = load i32, i32* %25
%1409 = load i32, i32* %15
%1410 = icmp sge i32 %1408, %1409
br i1 %1410, label %1411, label %1428
1411: ; preds = %1407
%1412 = load i32, i32* %25
%1413 = load i32, i32* %16
%1414 = icmp sle i32 %1412, %1413
br i1 %1414, label %1415, label %1428
1415: ; preds = %1411
%1416 = load i32, i32* %53
%1417 = trunc i32 %1416 to i8
%1418 = load i8*, i8** %10
%1419 = load i32, i32* %23
%1420 = load i32, i32* %24
%1421 = mul nsw i32 %1419, %1420
%1422 = load i32, i32* %25
%1423 = load i32, i32* %15
%1424 = sub nsw i32 %1422, %1423
%1425 = mul nsw i32 %1421, %1424
%1426 = sext i32 %1425 to i64
%1427 = getelementptr inbounds i8, i8* %1418, i64 %1426
store i8 %1417, i8* %1427
br label %1428
1428: ; preds = %1415, %1411, %1407
%1429 = load i32, i32* %25
%1430 = load i32, i32* %17
%1431 = icmp sge i32 %1429, %1430
br i1 %1431, label %1432, label %1449
1432: ; preds = %1428
%1433 = load i32, i32* %25
%1434 = load i32, i32* %18
%1435 = icmp sle i32 %1433, %1434
br i1 %1435, label %1436, label %1449
1436: ; preds = %1432
%1437 = load i32, i32* %53
%1438 = trunc i32 %1437 to i8
%1439 = load i8*, i8** %11
%1440 = load i32, i32* %23
%1441 = load i32, i32* %24
%1442 = mul nsw i32 %1440, %1441
%1443 = load i32, i32* %25
%1444 = load i32, i32* %17
%1445 = sub nsw i32 %1443, %1444
%1446 = mul nsw i32 %1442, %1445
%1447 = sext i32 %1446 to i64
%1448 = getelementptr inbounds i8, i8* %1439, i64 %1447
store i8 %1438, i8* %1448
br label %1449
1449: ; preds = %1436, %1432, %1428
br label %1450
1450: ; preds = %1449, %1389
%1451 = load i32, i32* %46
%1452 = icmp ne i32 %1451, 0
br i1 %1452, label %1453, label %1511
1453: ; preds = %1450
%1454 = load i32, i32* %28
%1455 = load i32, i32* %14
%1456 = icmp sle i32 %1454, %1455
br i1 %1456, label %1457, label %1468
1457: ; preds = %1453
%1458 = load i32, i32* %54
%1459 = trunc i32 %1458 to i8
%1460 = load i8*, i8** %9
%1461 = load i32, i32* %26
%1462 = load i32, i32* %27
%1463 = mul nsw i32 %1461, %1462
%1464 = load i32, i32* %28
%1465 = mul nsw i32 %1463, %1464
%1466 = sext i32 %1465 to i64
%1467 = getelementptr inbounds i8, i8* %1460, i64 %1466
store i8 %1459, i8* %1467
br label %1468
1468: ; preds = %1457, %1453
%1469 = load i32, i32* %28
%1470 = load i32, i32* %15
%1471 = icmp sge i32 %1469, %1470
br i1 %1471, label %1472, label %1489
1472: ; preds = %1468
%1473 = load i32, i32* %28
%1474 = load i32, i32* %16
%1475 = icmp sle i32 %1473, %1474
br i1 %1475, label %1476, label %1489
1476: ; preds = %1472
%1477 = load i32, i32* %54
%1478 = trunc i32 %1477 to i8
%1479 = load i8*, i8** %10
%1480 = load i32, i32* %26
%1481 = load i32, i32* %27
%1482 = mul nsw i32 %1480, %1481
%1483 = load i32, i32* %28
%1484 = load i32, i32* %15
%1485 = sub nsw i32 %1483, %1484
%1486 = mul nsw i32 %1482, %1485
%1487 = sext i32 %1486 to i64
%1488 = getelementptr inbounds i8, i8* %1479, i64 %1487
store i8 %1478, i8* %1488
br label %1489
1489: ; preds = %1476, %1472, %1468
%1490 = load i32, i32* %28
%1491 = load i32, i32* %17
%1492 = icmp sge i32 %1490, %1491
br i1 %1492, label %1493, label %1510
1493: ; preds = %1489
%1494 = load i32, i32* %28
%1495 = load i32, i32* %18
%1496 = icmp sle i32 %1494, %1495
br i1 %1496, label %1497, label %1510
1497: ; preds = %1493
%1498 = load i32, i32* %54
%1499 = trunc i32 %1498 to i8
%1500 = load i8*, i8** %11
%1501 = load i32, i32* %26
%1502 = load i32, i32* %27
%1503 = mul nsw i32 %1501, %1502
%1504 = load i32, i32* %28
%1505 = load i32, i32* %17
%1506 = sub nsw i32 %1504, %1505
%1507 = mul nsw i32 %1503, %1506
%1508 = sext i32 %1507 to i64
%1509 = getelementptr inbounds i8, i8* %1500, i64 %1508
store i8 %1499, i8* %1509
br label %1510
1510: ; preds = %1497, %1493, %1489
br label %1511
1511: ; preds = %1510, %1450
%1512 = load i32, i32* %47
%1513 = icmp ne i32 %1512, 0
br i1 %1513, label %1514, label %1572
1514: ; preds = %1511
%1515 = load i32, i32* %31
%1516 = load i32, i32* %14
%1517 = icmp sle i32 %1515, %1516
br i1 %1517, label %1518, label %1529
1518: ; preds = %1514
%1519 = load i32, i32* %55
%1520 = trunc i32 %1519 to i8
%1521 = load i8*, i8** %9
%1522 = load i32, i32* %29
%1523 = load i32, i32* %30
%1524 = mul nsw i32 %1522, %1523
%1525 = load i32, i32* %31
%1526 = mul nsw i32 %1524, %1525
%1527 = sext i32 %1526 to i64
%1528 = getelementptr inbounds i8, i8* %1521, i64 %1527
store i8 %1520, i8* %1528
br label %1529
1529: ; preds = %1518, %1514
%1530 = load i32, i32* %31
%1531 = load i32, i32* %15
%1532 = icmp sge i32 %1530, %1531
br i1 %1532, label %1533, label %1550
1533: ; preds = %1529
%1534 = load i32, i32* %31
%1535 = load i32, i32* %16
%1536 = icmp sle i32 %1534, %1535
br i1 %1536, label %1537, label %1550
1537: ; preds = %1533
%1538 = load i32, i32* %55
%1539 = trunc i32 %1538 to i8
%1540 = load i8*, i8** %10
%1541 = load i32, i32* %29
%1542 = load i32, i32* %30
%1543 = mul nsw i32 %1541, %1542
%1544 = load i32, i32* %31
%1545 = load i32, i32* %15
%1546 = sub nsw i32 %1544, %1545
%1547 = mul nsw i32 %1543, %1546
%1548 = sext i32 %1547 to i64
%1549 = getelementptr inbounds i8, i8* %1540, i64 %1548
store i8 %1539, i8* %1549
br label %1550
1550: ; preds = %1537, %1533, %1529
%1551 = load i32, i32* %31
%1552 = load i32, i32* %17
%1553 = icmp sge i32 %1551, %1552
br i1 %1553, label %1554, label %1571
1554: ; preds = %1550
%1555 = load i32, i32* %31
%1556 = load i32, i32* %18
%1557 = icmp sle i32 %1555, %1556
br i1 %1557, label %1558, label %1571
1558: ; preds = %1554
%1559 = load i32, i32* %55
%1560 = trunc i32 %1559 to i8
%1561 = load i8*, i8** %11
%1562 = load i32, i32* %29
%1563 = load i32, i32* %30
%1564 = mul nsw i32 %1562, %1563
%1565 = load i32, i32* %31
%1566 = load i32, i32* %17
%1567 = sub nsw i32 %1565, %1566
%1568 = mul nsw i32 %1564, %1567
%1569 = sext i32 %1568 to i64
%1570 = getelementptr inbounds i8, i8* %1561, i64 %1569
store i8 %1560, i8* %1570
br label %1571
1571: ; preds = %1558, %1554, %1550
br label %1572
1572: ; preds = %1571, %1511
%1573 = load i32, i32* %48
%1574 = icmp ne i32 %1573, 0
br i1 %1574, label %1575, label %1633
1575: ; preds = %1572
%1576 = load i32, i32* %34
%1577 = load i32, i32* %14
%1578 = icmp sle i32 %1576, %1577
br i1 %1578, label %1579, label %1590
1579: ; preds = %1575
%1580 = load i32, i32* %56
%1581 = trunc i32 %1580 to i8
%1582 = load i8*, i8** %9
%1583 = load i32, i32* %32
%1584 = load i32, i32* %33
%1585 = mul nsw i32 %1583, %1584
%1586 = load i32, i32* %34
%1587 = mul nsw i32 %1585, %1586
%1588 = sext i32 %1587 to i64
%1589 = getelementptr inbounds i8, i8* %1582, i64 %1588
store i8 %1581, i8* %1589
br label %1590
1590: ; preds = %1579, %1575
%1591 = load i32, i32* %34
%1592 = load i32, i32* %15
%1593 = icmp sge i32 %1591, %1592
br i1 %1593, label %1594, label %1611
1594: ; preds = %1590
%1595 = load i32, i32* %34
%1596 = load i32, i32* %16
%1597 = icmp sle i32 %1595, %1596
br i1 %1597, label %1598, label %1611
1598: ; preds = %1594
%1599 = load i32, i32* %56
%1600 = trunc i32 %1599 to i8
%1601 = load i8*, i8** %10
%1602 = load i32, i32* %32
%1603 = load i32, i32* %33
%1604 = mul nsw i32 %1602, %1603
%1605 = load i32, i32* %34
%1606 = load i32, i32* %15
%1607 = sub nsw i32 %1605, %1606
%1608 = mul nsw i32 %1604, %1607
%1609 = sext i32 %1608 to i64
%1610 = getelementptr inbounds i8, i8* %1601, i64 %1609
store i8 %1600, i8* %1610
br label %1611
1611: ; preds = %1598, %1594, %1590
%1612 = load i32, i32* %34
%1613 = load i32, i32* %17
%1614 = icmp sge i32 %1612, %1613
br i1 %1614, label %1615, label %1632
1615: ; preds = %1611
%1616 = load i32, i32* %34
%1617 = load i32, i32* %18
%1618 = icmp sle i32 %1616, %1617
br i1 %1618, label %1619, label %1632
1619: ; preds = %1615
%1620 = load i32, i32* %56
%1621 = trunc i32 %1620 to i8
%1622 = load i8*, i8** %11
%1623 = load i32, i32* %32
%1624 = load i32, i32* %33
%1625 = mul nsw i32 %1623, %1624
%1626 = load i32, i32* %34
%1627 = load i32, i32* %17
%1628 = sub nsw i32 %1626, %1627
%1629 = mul nsw i32 %1625, %1628
%1630 = sext i32 %1629 to i64
%1631 = getelementptr inbounds i8, i8* %1622, i64 %1630
store i8 %1621, i8* %1631
br label %1632
1632: ; preds = %1619, %1615, %1611
br label %1633
1633: ; preds = %1632, %1572
%1634 = load i32, i32* %49
%1635 = icmp ne i32 %1634, 0
br i1 %1635, label %1636, label %1692
1636: ; preds = %1633
%1637 = load i32, i32* %37
%1638 = load i32, i32* %14
%1639 = icmp sle i32 %1637, %1638
br i1 %1639, label %1640, label %1651
1640: ; preds = %1636
%1641 = load i32, i32* %57
%1642 = trunc i32 %1641 to i8
%1643 = load i8*, i8** %9
%1644 = load i32, i32* %35
%1645 = load i32, i32* %36
%1646 = mul nsw i32 %1644, %1645
%1647 = load i32, i32* %37
%1648 = mul nsw i32 %1646, %1647
%1649 = sext i32 %1648 to i64
%1650 = getelementptr inbounds i8, i8* %1643, i64 %1649
store i8 %1642, i8* %1650
br label %1651
1651: ; preds = %1640, %1636
%1652 = load i32, i32* %37
%1653 = load i32, i32* %15
%1654 = icmp sge i32 %1652, %1653
br i1 %1654, label %1655, label %1671
1655: ; preds = %1651
%1656 = load i32, i32* %37
%1657 = load i32, i32* %16
%1658 = icmp sle i32 %1656, %1657
br i1 %1658, label %1659, label %1671
1659: ; preds = %1655
%1660 = load i32, i32* %57
%1661 = trunc i32 %1660 to i8
%1662 = load i8*, i8** %10
%1663 = load i32, i32* %35
%1664 = load i32, i32* %36
%1665 = mul nsw i32 %1663, %1664
%1666 = load i32, i32* %37
%1667 = sub nsw i32 %1666, 620
%1668 = mul nsw i32 %1665, %1667
%1669 = sext i32 %1668 to i64
%1670 = getelementptr inbounds i8, i8* %1662, i64 %1669
store i8 %1661, i8* %1670
br label %1671
1671: ; preds = %1659, %1655, %1651
%1672 = load i32, i32* %37
%1673 = load i32, i32* %17
%1674 = icmp sge i32 %1672, %1673
br i1 %1674, label %1675, label %1691
1675: ; preds = %1671
%1676 = load i32, i32* %37
%1677 = load i32, i32* %18
%1678 = icmp sle i32 %1676, %1677
br i1 %1678, label %1679, label %1691
1679: ; preds = %1675
%1680 = load i32, i32* %57
%1681 = trunc i32 %1680 to i8
%1682 = load i8*, i8** %11
%1683 = load i32, i32* %35
%1684 = load i32, i32* %36
%1685 = mul nsw i32 %1683, %1684
%1686 = load i32, i32* %37
%1687 = sub nsw i32 %1686, 1240
%1688 = mul nsw i32 %1685, %1687
%1689 = sext i32 %1688 to i64
%1690 = getelementptr inbounds i8, i8* %1682, i64 %1689
store i8 %1681, i8* %1690
br label %1691
1691: ; preds = %1679, %1675, %1671
br label %1692
1692: ; preds = %1691, %1633
%1693 = load i32, i32* %50
%1694 = icmp ne i32 %1693, 0
br i1 %1694, label %1695, label %1753
1695: ; preds = %1692
%1696 = load i32, i32* %40
%1697 = load i32, i32* %14
%1698 = icmp sle i32 %1696, %1697
br i1 %1698, label %1699, label %1710
1699: ; preds = %1695
%1700 = load i32, i32* %58
%1701 = trunc i32 %1700 to i8
%1702 = load i8*, i8** %9
%1703 = load i32, i32* %38
%1704 = load i32, i32* %39
%1705 = mul nsw i32 %1703, %1704
%1706 = load i32, i32* %40
%1707 = mul nsw i32 %1705, %1706
%1708 = sext i32 %1707 to i64
%1709 = getelementptr inbounds i8, i8* %1702, i64 %1708
store i8 %1701, i8* %1709
br label %1710
1710: ; preds = %1699, %1695
%1711 = load i32, i32* %40
%1712 = load i32, i32* %15
%1713 = icmp sge i32 %1711, %1712
br i1 %1713, label %1714, label %1731
1714: ; preds = %1710
%1715 = load i32, i32* %40
%1716 = load i32, i32* %16
%1717 = icmp sle i32 %1715, %1716
br i1 %1717, label %1718, label %1731
1718: ; preds = %1714
%1719 = load i32, i32* %58
%1720 = trunc i32 %1719 to i8
%1721 = load i8*, i8** %10
%1722 = load i32, i32* %38
%1723 = load i32, i32* %39
%1724 = mul nsw i32 %1722, %1723
%1725 = load i32, i32* %40
%1726 = load i32, i32* %15
%1727 = sub nsw i32 %1725, %1726
%1728 = mul nsw i32 %1724, %1727
%1729 = sext i32 %1728 to i64
%1730 = getelementptr inbounds i8, i8* %1721, i64 %1729
store i8 %1720, i8* %1730
br label %1731
1731: ; preds = %1718, %1714, %1710
%1732 = load i32, i32* %40
%1733 = load i32, i32* %17
%1734 = icmp sge i32 %1732, %1733
br i1 %1734, label %1735, label %1752
1735: ; preds = %1731
%1736 = load i32, i32* %40
%1737 = load i32, i32* %18
%1738 = icmp sle i32 %1736, %1737
br i1 %1738, label %1739, label %1752
1739: ; preds = %1735
%1740 = load i32, i32* %58
%1741 = trunc i32 %1740 to i8
%1742 = load i8*, i8** %11
%1743 = load i32, i32* %38
%1744 = load i32, i32* %39
%1745 = mul nsw i32 %1743, %1744
%1746 = load i32, i32* %40
%1747 = load i32, i32* %17
%1748 = sub nsw i32 %1746, %1747
%1749 = mul nsw i32 %1745, %1748
%1750 = sext i32 %1749 to i64
%1751 = getelementptr inbounds i8, i8* %1742, i64 %1750
store i8 %1741, i8* %1751
br label %1752
1752: ; preds = %1739, %1735, %1731
br label %1753
1753: ; preds = %1752, %1692
%1754 = load i32, i32* %51
%1755 = icmp ne i32 %1754, 0
br i1 %1755, label %1756, label %1814
1756: ; preds = %1753
%1757 = load i32, i32* %43
%1758 = load i32, i32* %14
%1759 = icmp sle i32 %1757, %1758
br i1 %1759, label %1760, label %1771
1760: ; preds = %1756
%1761 = load i32, i32* %59
%1762 = trunc i32 %1761 to i8
%1763 = load i8*, i8** %9
%1764 = load i32, i32* %41
%1765 = load i32, i32* %42
%1766 = mul nsw i32 %1764, %1765
%1767 = load i32, i32* %43
%1768 = mul nsw i32 %1766, %1767
%1769 = sext i32 %1768 to i64
%1770 = getelementptr inbounds i8, i8* %1763, i64 %1769
store i8 %1762, i8* %1770
br label %1771
1771: ; preds = %1760, %1756
%1772 = load i32, i32* %43
%1773 = load i32, i32* %15
%1774 = icmp sge i32 %1772, %1773
br i1 %1774, label %1775, label %1792
1775: ; preds = %1771
%1776 = load i32, i32* %43
%1777 = load i32, i32* %16
%1778 = icmp sle i32 %1776, %1777
br i1 %1778, label %1779, label %1792
1779: ; preds = %1775
%1780 = load i32, i32* %59
%1781 = trunc i32 %1780 to i8
%1782 = load i8*, i8** %10
%1783 = load i32, i32* %41
%1784 = load i32, i32* %42
%1785 = mul nsw i32 %1783, %1784
%1786 = load i32, i32* %43
%1787 = load i32, i32* %15
%1788 = sub nsw i32 %1786, %1787
%1789 = mul nsw i32 %1785, %1788
%1790 = sext i32 %1789 to i64
%1791 = getelementptr inbounds i8, i8* %1782, i64 %1790
store i8 %1781, i8* %1791
br label %1792
1792: ; preds = %1779, %1775, %1771
%1793 = load i32, i32* %43
%1794 = load i32, i32* %17
%1795 = icmp sge i32 %1793, %1794
br i1 %1795, label %1796, label %1813
1796: ; preds = %1792
%1797 = load i32, i32* %43
%1798 = load i32, i32* %18
%1799 = icmp sle i32 %1797, %1798
br i1 %1799, label %1800, label %1813
1800: ; preds = %1796
%1801 = load i32, i32* %59
%1802 = trunc i32 %1801 to i8
%1803 = load i8*, i8** %11
%1804 = load i32, i32* %41
%1805 = load i32, i32* %42
%1806 = mul nsw i32 %1804, %1805
%1807 = load i32, i32* %43
%1808 = load i32, i32* %17
%1809 = sub nsw i32 %1807, %1808
%1810 = mul nsw i32 %1806, %1809
%1811 = sext i32 %1810 to i64
%1812 = getelementptr inbounds i8, i8* %1803, i64 %1811
store i8 %1802, i8* %1812
br label %1813
1813: ; preds = %1800, %1796, %1792
br label %1814
1814: ; preds = %1813, %1753
%1815 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.92, i64 0, i64 0))
%1816 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.93, i64 0, i64 0), i32* %6)
br label %1826
1817: ; preds = %407
%1818 = load i8*, i8** %9
%1819 = call i32 @free(i8* %1818)
%1820 = load i8*, i8** %10
%1821 = call i32 @free(i8* %1820)
%1822 = load i8*, i8** %11
%1823 = call i32 @free(i8* %1822)
%1824 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.103, i64 0, i64 0))
ret i32 0
1825: ; preds = %407
br label %120
1826: ; preds = %1814, %1327, %1245, %662, %660, %632, %630, %602, %600, %572, %570, %542, %540, %512, %510, %482, %480, %452, %450
br label %120
1827: ; preds = %120
%1828 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.104, i64 0, i64 0))
br label %1829
1829: ; preds = %1827, %1829
br label %1829
}

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