int main(int argc, char **argv) {
  unsigned idx = 0;
  for (; idx < 100; ++idx) {
    unsigned m = (unsigned)rand();
    if (m == 0) {
      idx--;
      continue;
    }
    unsigned x_u = (unsigned)rand();
    unsigned y_u = (unsigned)rand();
    unsigned z_u = (unsigned)rand();
    int x_s = (rand() % 2) ? rand() : -rand();
    int y_s = (rand() % 2) ? rand() : -rand();
    int z_s = (rand() % 2) ? rand() : -rand();
    if (!(((x_s) != (y_s)) || (((x_s) % (m)) == ((y_s) % (m))))) {
      printf("Test #%u, failed in iteration #: %u\n", 1, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((x_s) != (y_u)) || (((x_s) % (m)) == ((y_u) % (m))))) {
      printf("Test #%u, failed in iteration #: %u\n", 2, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((x_u) != (y_s)) || (((x_u) % (m)) == ((y_s) % (m))))) {
      printf("Test #%u, failed in iteration #: %u\n", 3, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((x_u) != (y_u)) || (((x_u) % (m)) == ((y_u) % (m))))) {
      printf("Test #%u, failed in iteration #: %u\n", 4, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((((x_u) % (m)) + ((y_u) % (m))) < ((x_u) % (m))) ||
          ((((x_u)) + ((y_u))) < ((x_u))) ||
          (((((x_u) % (m)) + ((y_u) % (m))) % m) == (((x_u) + (y_u)) % (m))))) {
      printf("Test #%u, failed in iteration #: %u\n", 5, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((((y_u)) + ((z_u))) < ((y_u))) || ((((x_u)) - ((z_u))) > ((x_u))) ||
          ((((x_u) % (m)) == (((y_u) + (z_u)) % (m))) % m) ==
              ((((x_u) - (z_u)) % (m)) == ((y_u) % (m))))) {
      printf("Test #%u, failed in iteration #: %u\n", 6, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((((y_u) * (m)) / (m)) != (y_u)) ||
          ((((x_u)) + ((y_u) * (m))) < ((x_u))) ||
          (((x_u) % (m)) == (((x_u) + ((y_u) * (m))) % (m))))) {
      printf("Test #%u, failed in iteration #: %u\n", 7, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!((gcd((z_s), (m)) != 1) || ((z_s) == 0) ||
          (gcd((x_s), (z_s)) != (z_s)) || ((gcd((y_s), (z_s)) != (z_s))) ||
          (((x_s) % (m)) == ((y_s) % (m))) ==
              (((((x_s) / (z_s)) % m) == (((y_s) / (z_s))) % m)))) {
      printf("Test #%u, failed in iteration #: %u\n", 8, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!((gcd((z_u), (m)) != 1) || ((z_u) == 0) ||
          (gcd((x_s), (z_u)) != (z_u)) || ((gcd((y_s), (z_u)) != (z_u))) ||
          (((x_s) % (m)) == ((y_s) % (m))) ==
              (((((x_s) / (z_u)) % m) == (((y_s) / (z_u))) % m)))) {
      printf("Test #%u, failed in iteration #: %u\n", 9, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!((gcd((z_s), (m)) != 1) || ((z_s) == 0) ||
          (gcd((x_s), (z_s)) != (z_s)) || ((gcd((y_u), (z_s)) != (z_s))) ||
          (((x_s) % (m)) == ((y_u) % (m))) ==
              (((((x_s) / (z_s)) % m) == (((y_u) / (z_s))) % m)))) {
      printf("Test #%u, failed in iteration #: %u\n", 10, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!((gcd((z_u), (m)) != 1) || ((z_u) == 0) ||
          (gcd((x_s), (z_u)) != (z_u)) || ((gcd((y_u), (z_u)) != (z_u))) ||
          (((x_s) % (m)) == ((y_u) % (m))) ==
              (((((x_s) / (z_u)) % m) == (((y_u) / (z_u))) % m)))) {
      printf("Test #%u, failed in iteration #: %u\n", 11, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!((gcd((z_s), (m)) != 1) || ((z_s) == 0) ||
          (gcd((x_u), (z_s)) != (z_s)) || ((gcd((y_s), (z_s)) != (z_s))) ||
          (((x_u) % (m)) == ((y_s) % (m))) ==
              (((((x_u) / (z_s)) % m) == (((y_s) / (z_s))) % m)))) {
      printf("Test #%u, failed in iteration #: %u\n", 12, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!((gcd((z_u), (m)) != 1) || ((z_u) == 0) ||
          (gcd((x_u), (z_u)) != (z_u)) || ((gcd((y_s), (z_u)) != (z_u))) ||
          (((x_u) % (m)) == ((y_s) % (m))) ==
              (((((x_u) / (z_u)) % m) == (((y_s) / (z_u))) % m)))) {
      printf("Test #%u, failed in iteration #: %u\n", 13, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!((gcd((z_s), (m)) != 1) || ((z_s) == 0) ||
          (gcd((x_u), (z_s)) != (z_s)) || ((gcd((y_u), (z_s)) != (z_s))) ||
          (((x_u) % (m)) == ((y_u) % (m))) ==
              (((((x_u) / (z_s)) % m) == (((y_u) / (z_s))) % m)))) {
      printf("Test #%u, failed in iteration #: %u\n", 14, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!((gcd((z_u), (m)) != 1) || ((z_u) == 0) ||
          (gcd((x_u), (z_u)) != (z_u)) || ((gcd((y_u), (z_u)) != (z_u))) ||
          (((x_u) % (m)) == ((y_u) % (m))) ==
              (((((x_u) / (z_u)) % m) == (((y_u) / (z_u))) % m)))) {
      printf("Test #%u, failed in iteration #: %u\n", 15, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_s) == 0) || (gcd((x_s), (z_s)) != (z_s)) ||
          (gcd((y_s), (z_s)) != (z_s)) || (gcd((m), (z_s)) != (z_s)) ||
          (((x_s) % (m)) == ((y_s) % (m))) ==
              ((((x_s) / (z_s)) % ((m) / (z_s))) ==
               (((y_s) / (z_s)) % ((m) / (z_s)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 16, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_u) == 0) || (gcd((x_s), (z_u)) != (z_u)) ||
          (gcd((y_s), (z_u)) != (z_u)) || (gcd((m), (z_u)) != (z_u)) ||
          (((x_s) % (m)) == ((y_s) % (m))) ==
              ((((x_s) / (z_u)) % ((m) / (z_u))) ==
               (((y_s) / (z_u)) % ((m) / (z_u)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 17, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_s) == 0) || (gcd((x_s), (z_s)) != (z_s)) ||
          (gcd((y_u), (z_s)) != (z_s)) || (gcd((m), (z_s)) != (z_s)) ||
          (((x_s) % (m)) == ((y_u) % (m))) ==
              ((((x_s) / (z_s)) % ((m) / (z_s))) ==
               (((y_u) / (z_s)) % ((m) / (z_s)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 18, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_u) == 0) || (gcd((x_s), (z_u)) != (z_u)) ||
          (gcd((y_u), (z_u)) != (z_u)) || (gcd((m), (z_u)) != (z_u)) ||
          (((x_s) % (m)) == ((y_u) % (m))) ==
              ((((x_s) / (z_u)) % ((m) / (z_u))) ==
               (((y_u) / (z_u)) % ((m) / (z_u)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 19, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_s) == 0) || (gcd((x_u), (z_s)) != (z_s)) ||
          (gcd((y_s), (z_s)) != (z_s)) || (gcd((m), (z_s)) != (z_s)) ||
          (((x_u) % (m)) == ((y_s) % (m))) ==
              ((((x_u) / (z_s)) % ((m) / (z_s))) ==
               (((y_s) / (z_s)) % ((m) / (z_s)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 20, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_u) == 0) || (gcd((x_u), (z_u)) != (z_u)) ||
          (gcd((y_s), (z_u)) != (z_u)) || (gcd((m), (z_u)) != (z_u)) ||
          (((x_u) % (m)) == ((y_s) % (m))) ==
              ((((x_u) / (z_u)) % ((m) / (z_u))) ==
               (((y_s) / (z_u)) % ((m) / (z_u)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 21, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_s) == 0) || (gcd((x_u), (z_s)) != (z_s)) ||
          (gcd((y_u), (z_s)) != (z_s)) || (gcd((m), (z_s)) != (z_s)) ||
          (((x_u) % (m)) == ((y_u) % (m))) ==
              ((((x_u) / (z_s)) % ((m) / (z_s))) ==
               (((y_u) / (z_s)) % ((m) / (z_s)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 22, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_u) == 0) || (gcd((x_u), (z_u)) != (z_u)) ||
          (gcd((y_u), (z_u)) != (z_u)) || (gcd((m), (z_u)) != (z_u)) ||
          (((x_u) % (m)) == ((y_u) % (m))) ==
              ((((x_u) / (z_u)) % ((m) / (z_u))) ==
               (((y_u) / (z_u)) % ((m) / (z_u)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 23, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_u) == 0) || (gcd((m), (z_u)) != (z_u)) ||
          ((((x_s) % (m)) == ((y_s) % (m))) ==
           (((x_s) % (z_u)) == ((y_s) % (z_u)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 25, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_u) == 0) || (gcd((m), (z_u)) != (z_u)) ||
          ((((x_s) % (m)) == ((y_u) % (m))) ==
           (((x_s) % (z_u)) == ((y_u) % (z_u)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 27, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_u) == 0) || (gcd((m), (z_u)) != (z_u)) ||
          ((((x_u) % (m)) == ((y_s) % (m))) ==
           (((x_u) % (z_u)) == ((y_s) % (z_u)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 29, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
    if (!(((z_u) == 0) || (gcd((m), (z_u)) != (z_u)) ||
          ((((x_u) % (m)) == ((y_u) % (m))) ==
           (((x_u) % (z_u)) == ((y_u) % (z_u)))))) {
      printf("Test #%u, failed in iteration #: %u\n", 31, idx);
      printf("Failing test vector:\n");
      printf("m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\n", m, x_u,
             y_u, z_u, x_s, y_s, z_s);
      return 1;
    };
  }
  printf("\n *** REM test done! ***\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1b0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jae    2d33 <main+0x1c03>
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jne    117c <main+0x4c>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    2d25 <main+0x1bf5>
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,-0x1c(%rbp)
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,-0x20(%rbp)
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,-0x24(%rbp)
mov    $0x0,%al
call   1050 <rand@plt>
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11c1 <main+0x91>
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,-0x34(%rbp)
jmp    11d1 <main+0xa1>
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    $0x0,%al
call   1050 <rand@plt>
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11fe <main+0xce>
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,-0x38(%rbp)
jmp    120e <main+0xde>
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    $0x0,%al
call   1050 <rand@plt>
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     123b <main+0x10b>
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,-0x3c(%rbp)
jmp    124b <main+0x11b>
mov    $0x0,%al
call   1050 <rand@plt>
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    12db <main+0x1ab>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x40(%rbp),%edx
cmp    %eax,%edx
je     12db <main+0x1ab>
mov    -0x14(%rbp),%edx
lea    0x1d79(%rip),%rdi
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1d8b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1d7b(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jne    1365 <main+0x235>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x44(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x44(%rbp),%edx
cmp    %eax,%edx
je     1365 <main+0x235>
mov    -0x14(%rbp),%edx
lea    0x1cef(%rip),%rdi
mov    $0x2,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1d01(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1cf1(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    13ef <main+0x2bf>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x48(%rbp),%edx
cmp    %eax,%edx
je     13ef <main+0x2bf>
mov    -0x14(%rbp),%edx
lea    0x1c65(%rip),%rdi
mov    $0x3,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1c77(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1c67(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jne    1479 <main+0x349>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x4c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x4c(%rbp),%edx
cmp    %eax,%edx
je     1479 <main+0x349>
mov    -0x14(%rbp),%edx
lea    0x1bdb(%rip),%rdi
mov    $0x4,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1bed(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1bdd(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x54(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x54(%rbp),%edx
add    %eax,%edx
mov    %edx,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x50(%rbp),%edx
cmp    %eax,%edx
jb     1550 <main+0x420>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jb     1550 <main+0x420>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x5c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0x5c(%rbp),%eax
add    %edx,%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x58(%rbp),%edx
cmp    %eax,%edx
je     1550 <main+0x420>
mov    -0x14(%rbp),%edx
lea    0x1b04(%rip),%rdi
mov    $0x5,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1b16(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1b06(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jb     1629 <main+0x4f9>
mov    -0x1c(%rbp),%eax
sub    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
ja     1629 <main+0x4f9>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x68(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x68(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x60(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x24(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x64(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0x64(%rbp),%eax
mov    %edx,%ecx
mov    -0x60(%rbp),%edx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
cmp    %eax,%edx
je     1629 <main+0x4f9>
mov    -0x14(%rbp),%edx
lea    0x1a2b(%rip),%rdi
mov    $0x6,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1a3d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1a2d(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x20(%rbp),%eax
imul   -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
cmp    -0x20(%rbp),%eax
jne    16da <main+0x5aa>
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    %ecx,%eax
cmp    -0x1c(%rbp),%eax
jb     16da <main+0x5aa>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x6c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    %ecx,%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x6c(%rbp),%edx
cmp    %eax,%edx
je     16da <main+0x5aa>
mov    -0x14(%rbp),%edx
lea    0x197a(%rip),%rdi
mov    $0x7,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x198c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x197c(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x30(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    $0x1,%eax
jne    17df <main+0x6af>
cmpl   $0x0,-0x30(%rbp)
je     17df <main+0x6af>
mov    -0x28(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    17df <main+0x6af>
mov    -0x2c(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    17df <main+0x6af>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x78(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x78(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x30(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x30(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0x74(%rbp),%eax
mov    %edx,%ecx
mov    -0x70(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     17df <main+0x6af>
mov    -0x14(%rbp),%edx
lea    0x1875(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1887(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1877(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x24(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    $0x1,%eax
jne    18ec <main+0x7bc>
cmpl   $0x0,-0x24(%rbp)
je     18ec <main+0x7bc>
mov    -0x28(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    18ec <main+0x7bc>
mov    -0x2c(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    18ec <main+0x7bc>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x84(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x84(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x80(%rbp)
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x7c(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0x80(%rbp),%eax
mov    %edx,%ecx
mov    -0x7c(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     18ec <main+0x7bc>
mov    -0x14(%rbp),%edx
lea    0x1768(%rip),%rdi
mov    $0x9,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x177a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x176a(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x30(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    $0x1,%eax
jne    1a04 <main+0x8d4>
cmpl   $0x0,-0x30(%rbp)
je     1a04 <main+0x8d4>
mov    -0x28(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    1a04 <main+0x8d4>
mov    -0x20(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    1a04 <main+0x8d4>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x90(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x90(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x30(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x88(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0x8c(%rbp),%eax
mov    %edx,%ecx
mov    -0x88(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     1a04 <main+0x8d4>
mov    -0x14(%rbp),%edx
lea    0x1650(%rip),%rdi
mov    $0xa,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1662(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1652(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x24(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    $0x1,%eax
jne    1b1d <main+0x9ed>
cmpl   $0x0,-0x24(%rbp)
je     1b1d <main+0x9ed>
mov    -0x28(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    1b1d <main+0x9ed>
mov    -0x20(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    1b1d <main+0x9ed>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x9c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x9c(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x98(%rbp)
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x94(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0x98(%rbp),%eax
mov    %edx,%ecx
mov    -0x94(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     1b1d <main+0x9ed>
mov    -0x14(%rbp),%edx
lea    0x1537(%rip),%rdi
mov    $0xb,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1549(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1539(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x30(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    $0x1,%eax
jne    1c35 <main+0xb05>
cmpl   $0x0,-0x30(%rbp)
je     1c35 <main+0xb05>
mov    -0x1c(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    1c35 <main+0xb05>
mov    -0x2c(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    1c35 <main+0xb05>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xa8(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0xa8(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xa0(%rbp)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x30(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0xa4(%rbp),%eax
mov    %edx,%ecx
mov    -0xa0(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     1c35 <main+0xb05>
mov    -0x14(%rbp),%edx
lea    0x141f(%rip),%rdi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1431(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1421(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x24(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    $0x1,%eax
jne    1d4e <main+0xc1e>
cmpl   $0x0,-0x24(%rbp)
je     1d4e <main+0xc1e>
mov    -0x1c(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    1d4e <main+0xc1e>
mov    -0x2c(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    1d4e <main+0xc1e>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xb4(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0xb4(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xac(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0xb0(%rbp),%eax
mov    %edx,%ecx
mov    -0xac(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     1d4e <main+0xc1e>
mov    -0x14(%rbp),%edx
lea    0x1306(%rip),%rdi
mov    $0xd,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1318(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x1308(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x30(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    $0x1,%eax
jne    1e67 <main+0xd37>
cmpl   $0x0,-0x30(%rbp)
je     1e67 <main+0xd37>
mov    -0x1c(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    1e67 <main+0xd37>
mov    -0x20(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    1e67 <main+0xd37>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xc0(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0xc0(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xb8(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0xbc(%rbp),%eax
mov    %edx,%ecx
mov    -0xb8(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     1e67 <main+0xd37>
mov    -0x14(%rbp),%edx
lea    0x11ed(%rip),%rdi
mov    $0xe,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x11ff(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x11ef(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
mov    -0x24(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    $0x1,%eax
jne    1f80 <main+0xe50>
cmpl   $0x0,-0x24(%rbp)
je     1f80 <main+0xe50>
mov    -0x1c(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    1f80 <main+0xe50>
mov    -0x20(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    1f80 <main+0xe50>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xcc(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0xcc(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xc8(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xc4(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0xc8(%rbp),%eax
mov    %edx,%ecx
mov    -0xc4(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     1f80 <main+0xe50>
mov    -0x14(%rbp),%edx
lea    0x10d4(%rip),%rdi
mov    $0xf,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x10e6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x10d6(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x30(%rbp)
je     20c1 <main+0xf91>
mov    -0x28(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    20c1 <main+0xf91>
mov    -0x2c(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    20c1 <main+0xf91>
mov    -0x18(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    20c1 <main+0xf91>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xe0(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0xe0(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd4(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    %eax,-0xdc(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,%ecx
mov    -0xdc(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %edx,-0xd0(%rbp)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    %eax,-0xd8(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,%ecx
mov    -0xd8(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    -0xd4(%rbp),%eax
mov    %edx,%ecx
mov    -0xd0(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     20c1 <main+0xf91>
mov    -0x14(%rbp),%edx
lea    0xf93(%rip),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfa5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0xf95(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x24(%rbp)
je     2204 <main+0x10d4>
mov    -0x28(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2204 <main+0x10d4>
mov    -0x2c(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2204 <main+0x10d4>
mov    -0x18(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2204 <main+0x10d4>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0xf4(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0xf4(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xe8(%rbp)
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,-0xf0(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,%ecx
mov    -0xf0(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %edx,-0xe4(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,-0xec(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,%ecx
mov    -0xec(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    -0xe8(%rbp),%eax
mov    %edx,%ecx
mov    -0xe4(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2204 <main+0x10d4>
mov    -0x14(%rbp),%edx
lea    0xe50(%rip),%rdi
mov    $0x11,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xe62(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0xe52(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x30(%rbp)
je     2346 <main+0x1216>
mov    -0x28(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    2346 <main+0x1216>
mov    -0x20(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    2346 <main+0x1216>
mov    -0x18(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    2346 <main+0x1216>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x108(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x108(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xfc(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    %eax,-0x104(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,%ecx
mov    -0x104(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %edx,-0xf8(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,-0x100(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,%ecx
mov    -0x100(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    -0xfc(%rbp),%eax
mov    %edx,%ecx
mov    -0xf8(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2346 <main+0x1216>
mov    -0x14(%rbp),%edx
lea    0xd0e(%rip),%rdi
mov    $0x12,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd20(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0xd10(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x24(%rbp)
je     2489 <main+0x1359>
mov    -0x28(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2489 <main+0x1359>
mov    -0x20(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2489 <main+0x1359>
mov    -0x18(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2489 <main+0x1359>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x11c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x11c(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x110(%rbp)
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,-0x118(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,%ecx
mov    -0x118(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %edx,-0x10c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,-0x114(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,%ecx
mov    -0x114(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    -0x110(%rbp),%eax
mov    %edx,%ecx
mov    -0x10c(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2489 <main+0x1359>
mov    -0x14(%rbp),%edx
lea    0xbcb(%rip),%rdi
mov    $0x13,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xbdd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0xbcd(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x30(%rbp)
je     25cb <main+0x149b>
mov    -0x1c(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    25cb <main+0x149b>
mov    -0x2c(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    25cb <main+0x149b>
mov    -0x18(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    25cb <main+0x149b>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x130(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x130(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x124(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,-0x12c(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,%ecx
mov    -0x12c(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %edx,-0x120(%rbp)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    %eax,-0x128(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,%ecx
mov    -0x128(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    -0x124(%rbp),%eax
mov    %edx,%ecx
mov    -0x120(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     25cb <main+0x149b>
mov    -0x14(%rbp),%edx
lea    0xa89(%rip),%rdi
mov    $0x14,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xa9b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0xa8b(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x24(%rbp)
je     270e <main+0x15de>
mov    -0x1c(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    270e <main+0x15de>
mov    -0x2c(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    270e <main+0x15de>
mov    -0x18(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    270e <main+0x15de>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x144(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x144(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x138(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,-0x140(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,%ecx
mov    -0x140(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %edx,-0x134(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,-0x13c(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,%ecx
mov    -0x13c(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    -0x138(%rbp),%eax
mov    %edx,%ecx
mov    -0x134(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     270e <main+0x15de>
mov    -0x14(%rbp),%edx
lea    0x946(%rip),%rdi
mov    $0x15,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x958(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x948(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x30(%rbp)
je     2851 <main+0x1721>
mov    -0x1c(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    2851 <main+0x1721>
mov    -0x20(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    2851 <main+0x1721>
mov    -0x18(%rbp),%edi
mov    -0x30(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x30(%rbp),%eax
jne    2851 <main+0x1721>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x158(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x158(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,-0x154(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,%ecx
mov    -0x154(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %edx,-0x148(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,-0x150(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x30(%rbp)
mov    %eax,%ecx
mov    -0x150(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    -0x14c(%rbp),%eax
mov    %edx,%ecx
mov    -0x148(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2851 <main+0x1721>
mov    -0x14(%rbp),%edx
lea    0x803(%rip),%rdi
mov    $0x16,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x815(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x805(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x24(%rbp)
je     2994 <main+0x1864>
mov    -0x1c(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2994 <main+0x1864>
mov    -0x20(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2994 <main+0x1864>
mov    -0x18(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2994 <main+0x1864>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x16c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x16c(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x160(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,-0x168(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,%ecx
mov    -0x168(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %edx,-0x15c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,-0x164(%rbp)
mov    -0x18(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %eax,%ecx
mov    -0x164(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    -0x160(%rbp),%eax
mov    %edx,%ecx
mov    -0x15c(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2994 <main+0x1864>
mov    -0x14(%rbp),%edx
lea    0x6c0(%rip),%rdi
mov    $0x17,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x6d2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x6c2(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x24(%rbp)
je     2a77 <main+0x1947>
mov    -0x18(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2a77 <main+0x1947>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x178(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x178(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x174(%rbp)
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %edx,-0x170(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    -0x174(%rbp),%eax
mov    %edx,%ecx
mov    -0x170(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2a77 <main+0x1947>
mov    -0x14(%rbp),%edx
lea    0x5dd(%rip),%rdi
mov    $0x19,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x5ef(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x5df(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x24(%rbp)
je     2b5a <main+0x1a2a>
mov    -0x18(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2b5a <main+0x1a2a>
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x184(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x184(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x180(%rbp)
mov    -0x28(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %edx,-0x17c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    -0x180(%rbp),%eax
mov    %edx,%ecx
mov    -0x17c(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2b5a <main+0x1a2a>
mov    -0x14(%rbp),%edx
lea    0x4fa(%rip),%rdi
mov    $0x1b,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x50c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x4fc(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x24(%rbp)
je     2c3d <main+0x1b0d>
mov    -0x18(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2c3d <main+0x1b0d>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x190(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x190(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x18c(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %edx,-0x188(%rbp)
mov    -0x2c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    -0x18c(%rbp),%eax
mov    %edx,%ecx
mov    -0x188(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2c3d <main+0x1b0d>
mov    -0x14(%rbp),%edx
lea    0x417(%rip),%rdi
mov    $0x1d,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x429(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x419(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
cmpl   $0x0,-0x24(%rbp)
je     2d20 <main+0x1bf0>
mov    -0x18(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <gcd@plt>
cmp    -0x24(%rbp),%eax
jne    2d20 <main+0x1bf0>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,-0x19c(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %edx,%eax
mov    -0x19c(%rbp),%edx
cmp    %eax,%edx
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x198(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    %edx,-0x194(%rbp)
mov    -0x20(%rbp),%eax
xor    %edx,%edx
divl   -0x24(%rbp)
mov    -0x198(%rbp),%eax
mov    %edx,%ecx
mov    -0x194(%rbp),%edx
cmp    %ecx,%edx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
je     2d20 <main+0x1bf0>
mov    -0x14(%rbp),%edx
lea    0x334(%rip),%rdi
mov    $0x1f,%esi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x346(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%eax
lea    0x336(%rip),%rdi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    2d48 <main+0x1c18>
jmp    2d25 <main+0x1bf5>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1150 <main+0x20>
lea    0x337(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
xor    %ebx,%ebx
jmp    1170 <main+0x30>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%ebx
add    $0x1,%ebx
cmp    $0x64,%ebx
jae    1ba8 <main+0xa68>
xor    %eax,%eax
call   1060 <rand@plt>
test   %eax,%eax
je     1ba0 <main+0xa60>
mov    %eax,%ecx
mov    %ebx,0x10(%rsp)
xor    %eax,%eax
mov    %ecx,0xc(%rsp)
call   1060 <rand@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   1060 <rand@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   1060 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1060 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1060 <rand@plt>
mov    %eax,%ecx
neg    %ecx
test   $0x1,%bl
cmovne %eax,%ecx
mov    %ecx,0x1c(%rsp)
xor    %eax,%eax
call   1060 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1060 <rand@plt>
mov    %eax,%r15d
neg    %r15d
test   $0x1,%bl
cmovne %eax,%r15d
xor    %eax,%eax
call   1060 <rand@plt>
mov    %eax,%r13d
xor    %eax,%eax
call   1060 <rand@plt>
mov    0xc(%rsp),%ebx
mov    %r12d,%edi
mov    %eax,%r12d
neg    %r12d
test   $0x1,%r13b
cmovne %eax,%r12d
mov    %edi,%eax
xor    %edx,%edx
div    %ebx
mov    %edx,%ecx
mov    %r14d,%eax
xor    %edx,%edx
div    %ebx
mov    %edx,0x18(%rsp)
mov    %edx,%eax
mov    %ecx,0x14(%rsp)
add    %ecx,%eax
jb     123f <main+0xff>
mov    %r14d,%ecx
add    %edi,%ecx
jb     123f <main+0xff>
xor    %edx,%edx
div    %ebx
mov    %edx,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %ebx
cmp    %edx,%esi
jne    1c86 <main+0xb46>
mov    %ebp,%eax
mov    %r14d,%r13d
add    %r14d,%eax
jb     1279 <main+0x139>
mov    %edi,%ecx
sub    %ebp,%ecx
jb     1279 <main+0x139>
xor    %edx,%edx
div    %ebx
xor    %eax,%eax
cmp    %edx,0x14(%rsp)
sete   %al
xor    %edx,%edx
div    %ebx
mov    %edx,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %ebx
xor    %eax,%eax
cmp    0x18(%rsp),%edx
sete   %al
cmp    %eax,%esi
jne    1bbb <main+0xa7b>
mov    %ebx,%eax
mul    %r13d
mov    %r15,0x20(%rsp)
jo     1297 <main+0x157>
add    %edi,%eax
jb     1297 <main+0x157>
xor    %edx,%edx
div    %ebx
cmp    %edx,0x14(%rsp)
jne    1cce <main+0xb8e>
mov    %edi,%r14d
mov    %r12d,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    $0x1,%eax
mov    0x1c(%rsp),%r15d
mov    0x20(%rsp),%rbx
jne    1320 <main+0x1e0>
test   %r12d,%r12d
je     1320 <main+0x1e0>
mov    %r15d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1320 <main+0x1e0>
mov    %ebx,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1320 <main+0x1e0>
mov    %r15d,%eax
xor    %edx,%edx
mov    0xc(%rsp),%edi
div    %edi
mov    %edx,%ecx
mov    %ebx,%eax
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
setne  %sil
mov    %r15d,%eax
cltd
idiv   %r12d
xor    %edx,%edx
div    %edi
mov    %edx,%ecx
mov    %ebx,%eax
cltd
idiv   %r12d
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1d10 <main+0xbd0>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    $0x1,%eax
jne    13a0 <main+0x260>
test   %ebp,%ebp
je     13a0 <main+0x260>
mov    %r15d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    13a0 <main+0x260>
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    13a0 <main+0x260>
mov    %r15d,%eax
xor    %edx,%edx
mov    0xc(%rsp),%edi
div    %edi
mov    %edx,%ecx
mov    %ebx,%eax
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
setne  %sil
mov    %r15d,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %edi
mov    %edx,%ecx
mov    %ebx,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1d21 <main+0xbe1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12d,%edi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    $0x1,%eax
jne    1420 <main+0x2e0>
test   %r12d,%r12d
je     1420 <main+0x2e0>
mov    %r15d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1420 <main+0x2e0>
mov    %r13d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1420 <main+0x2e0>
mov    %r15d,%eax
xor    %edx,%edx
mov    0xc(%rsp),%edi
div    %edi
cmp    0x18(%rsp),%edx
setne  %sil
mov    %r15d,%eax
cltd
idiv   %r12d
xor    %edx,%edx
div    %edi
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %r12d
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1d32 <main+0xbf2>
cs nopw 0x0(%rax,%rax,1)
mov    %ebp,%edi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    $0x1,%eax
jne    1490 <main+0x350>
test   %ebp,%ebp
je     1490 <main+0x350>
mov    %r15d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1490 <main+0x350>
mov    %r13d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1490 <main+0x350>
mov    %r15d,%eax
xor    %edx,%edx
mov    0xc(%rsp),%edi
div    %edi
cmp    0x18(%rsp),%edx
setne  %sil
mov    %r15d,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %edi
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1d43 <main+0xc03>
nop
mov    %r12d,%edi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    $0x1,%eax
jne    1510 <main+0x3d0>
test   %r12d,%r12d
je     1510 <main+0x3d0>
mov    %r14d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1510 <main+0x3d0>
mov    %ebx,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1510 <main+0x3d0>
mov    %ebx,%eax
xor    %edx,%edx
mov    0xc(%rsp),%edi
div    %edi
cmp    %edx,0x14(%rsp)
setne  %sil
mov    %r14d,%eax
xor    %edx,%edx
div    %r12d
xor    %edx,%edx
div    %edi
mov    %edx,%ecx
mov    %ebx,%eax
cltd
idiv   %r12d
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1d54 <main+0xc14>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,%edi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    $0x1,%eax
jne    1580 <main+0x440>
test   %ebp,%ebp
je     1580 <main+0x440>
mov    %r14d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1580 <main+0x440>
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1580 <main+0x440>
mov    %ebx,%eax
xor    %edx,%edx
mov    0xc(%rsp),%edi
div    %edi
cmp    %edx,0x14(%rsp)
setne  %sil
mov    %r14d,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %edi
mov    %edx,%ecx
mov    %ebx,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1d65 <main+0xc25>
nopl   0x0(%rax)
mov    %r12d,%edi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    $0x1,%eax
jne    1600 <main+0x4c0>
test   %r12d,%r12d
je     1600 <main+0x4c0>
mov    %r14d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1600 <main+0x4c0>
mov    %r13d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1600 <main+0x4c0>
mov    0x18(%rsp),%eax
cmp    %eax,0x14(%rsp)
setne  %sil
mov    %r14d,%eax
xor    %edx,%edx
div    %r12d
xor    %edx,%edx
mov    0xc(%rsp),%edi
div    %edi
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %r12d
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1d76 <main+0xc36>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebp,%edi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    $0x1,%eax
jne    1670 <main+0x530>
test   %ebp,%ebp
je     1670 <main+0x530>
mov    %r14d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1670 <main+0x530>
mov    %r13d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1670 <main+0x530>
mov    0x18(%rsp),%eax
cmp    %eax,0x14(%rsp)
setne  %sil
mov    %r14d,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
mov    0xc(%rsp),%edi
div    %edi
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %edi
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1d84 <main+0xc44>
nopl   0x0(%rax)
test   %r12d,%r12d
je     1700 <main+0x5c0>
mov    %r15d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1700 <main+0x5c0>
mov    %ebx,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1700 <main+0x5c0>
mov    0xc(%rsp),%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1700 <main+0x5c0>
mov    %r15d,%eax
xor    %edx,%edx
mov    0xc(%rsp),%esi
div    %esi
mov    %edx,%ecx
mov    %ebx,%eax
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
setne  %dil
mov    %r15d,%eax
cltd
idiv   %r12d
mov    %eax,%ecx
mov    %esi,%eax
xor    %edx,%edx
div    %r12d
mov    %eax,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%ecx
mov    %ebx,%eax
cltd
idiv   %r12d
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
sete   %al
xor    %dil,%al
je     1d92 <main+0xc52>
nopw   0x0(%rax,%rax,1)
test   %ebp,%ebp
je     1780 <main+0x640>
mov    %r15d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1780 <main+0x640>
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1780 <main+0x640>
mov    0xc(%rsp),%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1780 <main+0x640>
mov    %r15d,%eax
xor    %edx,%edx
mov    0xc(%rsp),%esi
div    %esi
mov    %edx,%ecx
mov    %ebx,%eax
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
setne  %dil
mov    %r15d,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,%ecx
mov    %esi,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%ecx
mov    %ebx,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
sete   %al
xor    %dil,%al
je     1da0 <main+0xc60>
xchg   %ax,%ax
test   %r12d,%r12d
je     1810 <main+0x6d0>
mov    %r15d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1810 <main+0x6d0>
mov    %r13d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1810 <main+0x6d0>
mov    0xc(%rsp),%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1810 <main+0x6d0>
mov    %r15d,%eax
xor    %edx,%edx
mov    0xc(%rsp),%esi
div    %esi
cmp    0x18(%rsp),%edx
setne  %dil
mov    %r15d,%eax
cltd
idiv   %r12d
mov    %eax,%ecx
mov    %esi,%eax
xor    %edx,%edx
div    %r12d
mov    %eax,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %r12d
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
sete   %al
xor    %dil,%al
je     1dae <main+0xc6e>
nopw   0x0(%rax,%rax,1)
test   %ebp,%ebp
je     1890 <main+0x750>
mov    %r15d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1890 <main+0x750>
mov    %r13d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1890 <main+0x750>
mov    0xc(%rsp),%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1890 <main+0x750>
mov    %r15d,%eax
xor    %edx,%edx
mov    0xc(%rsp),%esi
div    %esi
cmp    0x18(%rsp),%edx
setne  %dil
mov    %r15d,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,%ecx
mov    %esi,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
sete   %al
xor    %dil,%al
je     1dbc <main+0xc7c>
nopw   0x0(%rax,%rax,1)
test   %r12d,%r12d
je     1910 <main+0x7d0>
mov    %r14d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1910 <main+0x7d0>
mov    %ebx,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1910 <main+0x7d0>
mov    0xc(%rsp),%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1910 <main+0x7d0>
mov    %ebx,%eax
xor    %edx,%edx
mov    0xc(%rsp),%esi
div    %esi
cmp    %edx,0x14(%rsp)
setne  %dil
mov    %r14d,%eax
xor    %edx,%edx
div    %r12d
mov    %eax,%ecx
mov    %esi,%eax
xor    %edx,%edx
div    %r12d
mov    %eax,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%ecx
mov    %ebx,%eax
cltd
idiv   %r12d
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
sete   %al
xor    %dil,%al
je     1dca <main+0xc8a>
test   %ebp,%ebp
je     1990 <main+0x850>
mov    %r14d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1990 <main+0x850>
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1990 <main+0x850>
mov    0xc(%rsp),%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1990 <main+0x850>
mov    %ebx,%eax
xor    %edx,%edx
mov    0xc(%rsp),%esi
div    %esi
cmp    %edx,0x14(%rsp)
setne  %dil
mov    %r14d,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,%ecx
mov    %esi,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%ecx
mov    %ebx,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
sete   %al
xor    %dil,%al
je     1dd8 <main+0xc98>
nopw   0x0(%rax,%rax,1)
test   %r12d,%r12d
je     1a10 <main+0x8d0>
mov    %r14d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1a10 <main+0x8d0>
mov    %r13d,%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1a10 <main+0x8d0>
mov    0xc(%rsp),%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %r12d,%eax
jne    1a10 <main+0x8d0>
mov    0x18(%rsp),%eax
cmp    %eax,0x14(%rsp)
setne  %dil
mov    %r14d,%eax
xor    %edx,%edx
div    %r12d
mov    %eax,%ecx
mov    0xc(%rsp),%eax
xor    %edx,%edx
div    %r12d
mov    %eax,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %r12d
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
sete   %al
xor    %dil,%al
je     1de6 <main+0xca6>
nop
test   %ebp,%ebp
je     1160 <main+0x20>
mov    %r14d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1a90 <main+0x950>
mov    %r13d,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1a90 <main+0x950>
mov    0xc(%rsp),%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1a90 <main+0x950>
mov    0x18(%rsp),%eax
cmp    %eax,0x14(%rsp)
setne  %dil
mov    %r14d,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,%ecx
mov    0xc(%rsp),%eax
xor    %edx,%edx
div    %ebp
mov    %eax,%esi
mov    %ecx,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %ebp
xor    %edx,%edx
div    %esi
cmp    %edx,%ecx
sete   %al
xor    %dil,%al
je     1df4 <main+0xcb4>
nopl   0x0(%rax)
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1ada <main+0x99a>
mov    %r15d,%eax
xor    %edx,%edx
div    %ebx
mov    %edx,%ecx
mov    0x20(%rsp),%rdi
mov    %edi,%eax
xor    %edx,%edx
div    %ebx
cmp    %edx,%ecx
setne  %sil
mov    %r15d,%eax
xor    %edx,%edx
div    %ebp
mov    %edx,%ecx
mov    %edi,%eax
xor    %edx,%edx
div    %ebp
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1bf5 <main+0xab5>
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
mov    0xc(%rsp),%ebx
cmp    %ebp,%eax
jne    1b1a <main+0x9da>
mov    %r15d,%eax
xor    %edx,%edx
div    %ebx
cmp    0x18(%rsp),%edx
setne  %sil
mov    %r15d,%eax
xor    %edx,%edx
div    %ebp
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %ebp
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1c03 <main+0xac3>
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
mov    0xc(%rsp),%ebx
cmp    %ebp,%eax
jne    1b5d <main+0xa1d>
mov    0x20(%rsp),%rdi
mov    %edi,%eax
xor    %edx,%edx
div    %ebx
cmp    %edx,0x14(%rsp)
setne  %sil
mov    %r14d,%eax
xor    %edx,%edx
div    %ebp
mov    %edx,%ecx
mov    %edi,%eax
xor    %edx,%edx
div    %ebp
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
je     1c11 <main+0xad1>
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <gcd@plt>
cmp    %ebp,%eax
jne    1160 <main+0x20>
mov    0x18(%rsp),%eax
cmp    %eax,0x14(%rsp)
setne  %sil
mov    %r14d,%eax
xor    %edx,%edx
div    %ebp
mov    %edx,%ecx
mov    %r13d,%eax
xor    %edx,%edx
div    %ebp
cmp    %edx,%ecx
sete   %al
xor    %sil,%al
jne    1160 <main+0x20>
jmp    1c3f <main+0xaff>
nop
add    $0xffffffff,%ebx
jmp    1164 <main+0x24>
lea    0x4ac(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
jmp    1e41 <main+0xd01>
mov    %edi,%r14d
lea    0x43b(%rip),%rdi
mov    $0x6,%esi
mov    0x10(%rsp),%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x498(%rip),%rdi
call   1030 <puts@plt>
lea    0x43d(%rip),%rdi
mov    %ebx,%esi
mov    %r14d,%edx
mov    %r13d,%ecx
jmp    1cbb <main+0xb7b>
lea    0x404(%rip),%rdi
mov    $0x19,%esi
jmp    1c1d <main+0xadd>
lea    0x3f6(%rip),%rdi
mov    $0x1b,%esi
jmp    1c1d <main+0xadd>
lea    0x3e8(%rip),%rdi
mov    $0x1d,%esi
mov    0x10(%rsp),%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x445(%rip),%rdi
call   1030 <puts@plt>
lea    0x3ea(%rip),%rdi
mov    %ebx,%esi
jmp    1c6d <main+0xb2d>
lea    0x3ba(%rip),%rdi
mov    $0x1f,%esi
mov    0x10(%rsp),%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x417(%rip),%rdi
call   1030 <puts@plt>
lea    0x3bc(%rip),%rdi
mov    0xc(%rsp),%esi
mov    %r14d,%edx
mov    %r13d,%ecx
mov    %ebp,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   %r12
push   0x28(%rsp)
jmp    1e33 <main+0xcf3>
mov    %edi,%r13d
lea    0x370(%rip),%rdi
mov    $0x5,%esi
mov    0x10(%rsp),%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x3cd(%rip),%rdi
call   1030 <puts@plt>
lea    0x372(%rip),%rdi
mov    %ebx,%esi
mov    %r13d,%edx
mov    %r14d,%ecx
mov    %ebp,%r8d
mov    0x1c(%rsp),%r9d
xor    %eax,%eax
push   %r12
push   %r15
jmp    1e33 <main+0xcf3>
mov    %edi,%r14d
lea    0x328(%rip),%rdi
mov    $0x7,%esi
mov    0x10(%rsp),%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x385(%rip),%rdi
call   1030 <puts@plt>
lea    0x32a(%rip),%rdi
mov    %ebx,%esi
mov    %r14d,%edx
mov    %r13d,%ecx
mov    %ebp,%r8d
mov    0x1c(%rsp),%r9d
jmp    1c79 <main+0xb39>
lea    0x2e9(%rip),%rdi
mov    $0x8,%esi
jmp    1e00 <main+0xcc0>
lea    0x2d8(%rip),%rdi
mov    $0x9,%esi
jmp    1e00 <main+0xcc0>
lea    0x2c7(%rip),%rdi
mov    $0xa,%esi
jmp    1e00 <main+0xcc0>
lea    0x2b6(%rip),%rdi
mov    $0xb,%esi
jmp    1e00 <main+0xcc0>
lea    0x2a5(%rip),%rdi
mov    $0xc,%esi
jmp    1e00 <main+0xcc0>
lea    0x294(%rip),%rdi
mov    $0xd,%esi
jmp    1e00 <main+0xcc0>
lea    0x283(%rip),%rdi
mov    $0xe,%esi
jmp    1e00 <main+0xcc0>
lea    0x275(%rip),%rdi
mov    $0xf,%esi
jmp    1e00 <main+0xcc0>
lea    0x267(%rip),%rdi
mov    $0x10,%esi
jmp    1e00 <main+0xcc0>
lea    0x259(%rip),%rdi
mov    $0x11,%esi
jmp    1e00 <main+0xcc0>
lea    0x24b(%rip),%rdi
mov    $0x12,%esi
jmp    1e00 <main+0xcc0>
lea    0x23d(%rip),%rdi
mov    $0x13,%esi
jmp    1e00 <main+0xcc0>
lea    0x22f(%rip),%rdi
mov    $0x14,%esi
jmp    1e00 <main+0xcc0>
lea    0x221(%rip),%rdi
mov    $0x15,%esi
jmp    1e00 <main+0xcc0>
lea    0x213(%rip),%rdi
mov    $0x16,%esi
jmp    1e00 <main+0xcc0>
lea    0x205(%rip),%rdi
mov    $0x17,%esi
mov    0x10(%rsp),%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x262(%rip),%rdi
call   1030 <puts@plt>
lea    0x207(%rip),%rdi
mov    0xc(%rsp),%esi
mov    %r14d,%edx
mov    %r13d,%ecx
mov    %ebp,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   %r12
push   %rbx
call   1040 <printf@plt>
add    $0x10,%rsp
mov    $0x1,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [37 x i8] c"Test #%u, failed in iteration #: %u\0A\00"
@.str.2 = [54 x i8] c"m=%u, x_u=%u, y_u=%u, z_u=%u, x_s=%d, y_s=%d, z_s=%d\0A\00"
@str = [25 x i8] c"\0A *** REM test done! ***\00"
@str.30 = [21 x i8] c"Failing test vector:\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
br label %3
3: ; preds = %2, %513
%4 = phi i32 [ 0, %2 ], [ %515, %513 ]
%5 = tail call i32 (...) @rand()
%6 = icmp eq i32 %5, 0
br i1 %6, label %7, label %9
7: ; preds = %3
%8 = add nsw i32 %4, -1
br label %513
9: ; preds = %3
%10 = tail call i32 (...) @rand()
%11 = tail call i32 (...) @rand()
%12 = tail call i32 (...) @rand()
%13 = tail call i32 (...) @rand()
%14 = and i32 %13, 1
%15 = icmp eq i32 %14, 0
%16 = tail call i32 (...) @rand()
%17 = sub nsw i32 0, %16
%18 = select i1 %15, i32 %17, i32 %16
%19 = tail call i32 (...) @rand()
%20 = and i32 %19, 1
%21 = icmp eq i32 %20, 0
%22 = tail call i32 (...) @rand()
%23 = sub nsw i32 0, %22
%24 = select i1 %21, i32 %23, i32 %22
%25 = tail call i32 (...) @rand()
%26 = and i32 %25, 1
%27 = icmp eq i32 %26, 0
%28 = tail call i32 (...) @rand()
%29 = sub nsw i32 0, %28
%30 = select i1 %27, i32 %29, i32 %28
%31 = urem i32 %10, %5
%32 = urem i32 %11, %5
%33 = add i32 %32, %31
%34 = icmp ult i32 %33, %31
br i1 %34, label %46, label %35
35: ; preds = %9
%36 = add i32 %11, %10
%37 = icmp ult i32 %36, %10
br i1 %37, label %46, label %38
38: ; preds = %35
%39 = urem i32 %33, %5
%40 = urem i32 %36, %5
%41 = icmp eq i32 %39, %40
br i1 %41, label %46, label %42
42: ; preds = %38
%43 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 5, i32 %4)
%44 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
46: ; preds = %38, %35, %9
%47 = add i32 %12, %11
%48 = icmp ult i32 %47, %11
%49 = icmp ult i32 %10, %12
%50 = select i1 %48, i1 true, i1 %49
br i1 %50, label %65, label %51
51: ; preds = %46
%52 = sub i32 %10, %12
%53 = urem i32 %47, %5
%54 = icmp eq i32 %31, %53
%55 = zext i1 %54 to i32
%56 = urem i32 %55, %5
%57 = urem i32 %52, %5
%58 = icmp eq i32 %57, %32
%59 = zext i1 %58 to i32
%60 = icmp eq i32 %56, %59
br i1 %60, label %65, label %61
61: ; preds = %51
%62 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 6, i32 %4)
%63 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%64 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
65: ; preds = %51, %46
%66 = tail call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %5, i32 %11)
%67 = extractvalue { i32, i1 } %66, 1
br i1 %67, label %79, label %68
68: ; preds = %65
%69 = extractvalue { i32, i1 } %66, 0
%70 = add i32 %69, %10
%71 = icmp ult i32 %70, %10
br i1 %71, label %79, label %72
72: ; preds = %68
%73 = urem i32 %70, %5
%74 = icmp eq i32 %31, %73
br i1 %74, label %79, label %75
75: ; preds = %72
%76 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 7, i32 %4)
%77 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%78 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
79: ; preds = %72, %68, %65
%80 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %30, i32 %5)
%81 = icmp ne i32 %80, 1
%82 = icmp eq i32 %30, 0
%83 = select i1 %81, i1 true, i1 %82
br i1 %83, label %104, label %84
84: ; preds = %79
%85 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %18, i32 %30)
%86 = icmp eq i32 %85, %30
br i1 %86, label %87, label %104
87: ; preds = %84
%88 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %24, i32 %30)
%89 = icmp eq i32 %88, %30
br i1 %89, label %90, label %104
90: ; preds = %87
%91 = urem i32 %18, %5
%92 = urem i32 %24, %5
%93 = icmp ne i32 %91, %92
%94 = sdiv i32 %18, %30
%95 = urem i32 %94, %5
%96 = sdiv i32 %24, %30
%97 = urem i32 %96, %5
%98 = icmp eq i32 %95, %97
%99 = xor i1 %93, %98
br i1 %99, label %104, label %100
100: ; preds = %90
%101 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 8, i32 %4)
%102 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%103 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
104: ; preds = %90, %87, %84, %79
%105 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %12, i32 %5)
%106 = icmp ne i32 %105, 1
%107 = icmp eq i32 %12, 0
%108 = select i1 %106, i1 true, i1 %107
br i1 %108, label %129, label %109
109: ; preds = %104
%110 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %18, i32 %12)
%111 = icmp eq i32 %110, %12
br i1 %111, label %112, label %129
112: ; preds = %109
%113 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %24, i32 %12)
%114 = icmp eq i32 %113, %12
br i1 %114, label %115, label %129
115: ; preds = %112
%116 = urem i32 %18, %5
%117 = urem i32 %24, %5
%118 = icmp ne i32 %116, %117
%119 = udiv i32 %18, %12
%120 = urem i32 %119, %5
%121 = udiv i32 %24, %12
%122 = urem i32 %121, %5
%123 = icmp eq i32 %120, %122
%124 = xor i1 %118, %123
br i1 %124, label %129, label %125
125: ; preds = %115
%126 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 9, i32 %4)
%127 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%128 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
129: ; preds = %115, %112, %109, %104
%130 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %30, i32 %5)
%131 = icmp ne i32 %130, 1
%132 = select i1 %131, i1 true, i1 %82
br i1 %132, label %152, label %133
133: ; preds = %129
%134 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %18, i32 %30)
%135 = icmp eq i32 %134, %30
br i1 %135, label %136, label %152
136: ; preds = %133
%137 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %11, i32 %30)
%138 = icmp eq i32 %137, %30
br i1 %138, label %139, label %152
139: ; preds = %136
%140 = urem i32 %18, %5
%141 = icmp ne i32 %140, %32
%142 = sdiv i32 %18, %30
%143 = urem i32 %142, %5
%144 = udiv i32 %11, %30
%145 = urem i32 %144, %5
%146 = icmp eq i32 %143, %145
%147 = xor i1 %141, %146
br i1 %147, label %152, label %148
148: ; preds = %139
%149 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 10, i32 %4)
%150 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%151 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
152: ; preds = %139, %136, %133, %129
%153 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %12, i32 %5)
%154 = icmp ne i32 %153, 1
%155 = select i1 %154, i1 true, i1 %107
br i1 %155, label %175, label %156
156: ; preds = %152
%157 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %18, i32 %12)
%158 = icmp eq i32 %157, %12
br i1 %158, label %159, label %175
159: ; preds = %156
%160 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %11, i32 %12)
%161 = icmp eq i32 %160, %12
br i1 %161, label %162, label %175
162: ; preds = %159
%163 = urem i32 %18, %5
%164 = icmp ne i32 %163, %32
%165 = udiv i32 %18, %12
%166 = urem i32 %165, %5
%167 = udiv i32 %11, %12
%168 = urem i32 %167, %5
%169 = icmp eq i32 %166, %168
%170 = xor i1 %164, %169
br i1 %170, label %175, label %171
171: ; preds = %162
%172 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 11, i32 %4)
%173 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%174 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
175: ; preds = %162, %159, %156, %152
%176 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %30, i32 %5)
%177 = icmp ne i32 %176, 1
%178 = select i1 %177, i1 true, i1 %82
br i1 %178, label %198, label %179
179: ; preds = %175
%180 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %10, i32 %30)
%181 = icmp eq i32 %180, %30
br i1 %181, label %182, label %198
182: ; preds = %179
%183 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %24, i32 %30)
%184 = icmp eq i32 %183, %30
br i1 %184, label %185, label %198
185: ; preds = %182
%186 = urem i32 %24, %5
%187 = icmp ne i32 %31, %186
%188 = udiv i32 %10, %30
%189 = urem i32 %188, %5
%190 = sdiv i32 %24, %30
%191 = urem i32 %190, %5
%192 = icmp eq i32 %189, %191
%193 = xor i1 %187, %192
br i1 %193, label %198, label %194
194: ; preds = %185
%195 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 12, i32 %4)
%196 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%197 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
198: ; preds = %185, %182, %179, %175
%199 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %12, i32 %5)
%200 = icmp ne i32 %199, 1
%201 = select i1 %200, i1 true, i1 %107
br i1 %201, label %221, label %202
202: ; preds = %198
%203 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %10, i32 %12)
%204 = icmp eq i32 %203, %12
br i1 %204, label %205, label %221
205: ; preds = %202
%206 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %24, i32 %12)
%207 = icmp eq i32 %206, %12
br i1 %207, label %208, label %221
208: ; preds = %205
%209 = urem i32 %24, %5
%210 = icmp ne i32 %31, %209
%211 = udiv i32 %10, %12
%212 = urem i32 %211, %5
%213 = udiv i32 %24, %12
%214 = urem i32 %213, %5
%215 = icmp eq i32 %212, %214
%216 = xor i1 %210, %215
br i1 %216, label %221, label %217
217: ; preds = %208
%218 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 13, i32 %4)
%219 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%220 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
221: ; preds = %208, %205, %202, %198
%222 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %30, i32 %5)
%223 = icmp ne i32 %222, 1
%224 = select i1 %223, i1 true, i1 %82
br i1 %224, label %243, label %225
225: ; preds = %221
%226 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %10, i32 %30)
%227 = icmp eq i32 %226, %30
br i1 %227, label %228, label %243
228: ; preds = %225
%229 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %11, i32 %30)
%230 = icmp eq i32 %229, %30
br i1 %230, label %231, label %243
231: ; preds = %228
%232 = icmp ne i32 %31, %32
%233 = udiv i32 %10, %30
%234 = urem i32 %233, %5
%235 = udiv i32 %11, %30
%236 = urem i32 %235, %5
%237 = icmp eq i32 %234, %236
%238 = xor i1 %232, %237
br i1 %238, label %243, label %239
239: ; preds = %231
%240 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 14, i32 %4)
%241 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%242 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
243: ; preds = %231, %228, %225, %221
%244 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %12, i32 %5)
%245 = icmp ne i32 %244, 1
%246 = select i1 %245, i1 true, i1 %107
br i1 %246, label %265, label %247
247: ; preds = %243
%248 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %10, i32 %12)
%249 = icmp eq i32 %248, %12
br i1 %249, label %250, label %265
250: ; preds = %247
%251 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %11, i32 %12)
%252 = icmp eq i32 %251, %12
br i1 %252, label %253, label %265
253: ; preds = %250
%254 = icmp ne i32 %31, %32
%255 = udiv i32 %10, %12
%256 = urem i32 %255, %5
%257 = udiv i32 %11, %12
%258 = urem i32 %257, %5
%259 = icmp eq i32 %256, %258
%260 = xor i1 %254, %259
br i1 %260, label %265, label %261
261: ; preds = %253
%262 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 15, i32 %4)
%263 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%264 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
265: ; preds = %253, %250, %247, %243
br i1 %82, label %290, label %266
266: ; preds = %265
%267 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %18, i32 %30)
%268 = icmp eq i32 %267, %30
br i1 %268, label %269, label %290
269: ; preds = %266
%270 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %24, i32 %30)
%271 = icmp eq i32 %270, %30
br i1 %271, label %272, label %290
272: ; preds = %269
%273 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %30)
%274 = icmp eq i32 %273, %30
br i1 %274, label %275, label %290
275: ; preds = %272
%276 = urem i32 %18, %5
%277 = urem i32 %24, %5
%278 = icmp ne i32 %276, %277
%279 = sdiv i32 %18, %30
%280 = udiv i32 %5, %30
%281 = urem i32 %279, %280
%282 = sdiv i32 %24, %30
%283 = urem i32 %282, %280
%284 = icmp eq i32 %281, %283
%285 = xor i1 %278, %284
br i1 %285, label %290, label %286
286: ; preds = %275
%287 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 16, i32 %4)
%288 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%289 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
290: ; preds = %275, %272, %269, %266, %265
br i1 %107, label %315, label %291
291: ; preds = %290
%292 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %18, i32 %12)
%293 = icmp eq i32 %292, %12
br i1 %293, label %294, label %315
294: ; preds = %291
%295 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %24, i32 %12)
%296 = icmp eq i32 %295, %12
br i1 %296, label %297, label %315
297: ; preds = %294
%298 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %12)
%299 = icmp eq i32 %298, %12
br i1 %299, label %300, label %315
300: ; preds = %297
%301 = urem i32 %18, %5
%302 = urem i32 %24, %5
%303 = icmp ne i32 %301, %302
%304 = udiv i32 %18, %12
%305 = udiv i32 %5, %12
%306 = urem i32 %304, %305
%307 = udiv i32 %24, %12
%308 = urem i32 %307, %305
%309 = icmp eq i32 %306, %308
%310 = xor i1 %303, %309
br i1 %310, label %315, label %311
311: ; preds = %300
%312 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 17, i32 %4)
%313 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%314 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
315: ; preds = %300, %297, %294, %291, %290
br i1 %82, label %339, label %316
316: ; preds = %315
%317 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %18, i32 %30)
%318 = icmp eq i32 %317, %30
br i1 %318, label %319, label %339
319: ; preds = %316
%320 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %11, i32 %30)
%321 = icmp eq i32 %320, %30
br i1 %321, label %322, label %339
322: ; preds = %319
%323 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %30)
%324 = icmp eq i32 %323, %30
br i1 %324, label %325, label %339
325: ; preds = %322
%326 = urem i32 %18, %5
%327 = icmp ne i32 %326, %32
%328 = sdiv i32 %18, %30
%329 = udiv i32 %5, %30
%330 = urem i32 %328, %329
%331 = udiv i32 %11, %30
%332 = urem i32 %331, %329
%333 = icmp eq i32 %330, %332
%334 = xor i1 %327, %333
br i1 %334, label %339, label %335
335: ; preds = %325
%336 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 18, i32 %4)
%337 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%338 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
339: ; preds = %325, %322, %319, %316, %315
br i1 %107, label %363, label %340
340: ; preds = %339
%341 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %18, i32 %12)
%342 = icmp eq i32 %341, %12
br i1 %342, label %343, label %363
343: ; preds = %340
%344 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %11, i32 %12)
%345 = icmp eq i32 %344, %12
br i1 %345, label %346, label %363
346: ; preds = %343
%347 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %12)
%348 = icmp eq i32 %347, %12
br i1 %348, label %349, label %363
349: ; preds = %346
%350 = urem i32 %18, %5
%351 = icmp ne i32 %350, %32
%352 = udiv i32 %18, %12
%353 = udiv i32 %5, %12
%354 = urem i32 %352, %353
%355 = udiv i32 %11, %12
%356 = urem i32 %355, %353
%357 = icmp eq i32 %354, %356
%358 = xor i1 %351, %357
br i1 %358, label %363, label %359
359: ; preds = %349
%360 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 19, i32 %4)
%361 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%362 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
363: ; preds = %349, %346, %343, %340, %339
br i1 %82, label %387, label %364
364: ; preds = %363
%365 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %10, i32 %30)
%366 = icmp eq i32 %365, %30
br i1 %366, label %367, label %387
367: ; preds = %364
%368 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %24, i32 %30)
%369 = icmp eq i32 %368, %30
br i1 %369, label %370, label %387
370: ; preds = %367
%371 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %30)
%372 = icmp eq i32 %371, %30
br i1 %372, label %373, label %387
373: ; preds = %370
%374 = urem i32 %24, %5
%375 = icmp ne i32 %31, %374
%376 = udiv i32 %10, %30
%377 = udiv i32 %5, %30
%378 = urem i32 %376, %377
%379 = sdiv i32 %24, %30
%380 = urem i32 %379, %377
%381 = icmp eq i32 %378, %380
%382 = xor i1 %375, %381
br i1 %382, label %387, label %383
383: ; preds = %373
%384 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 20, i32 %4)
%385 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%386 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
387: ; preds = %373, %370, %367, %364, %363
br i1 %107, label %411, label %388
388: ; preds = %387
%389 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %10, i32 %12)
%390 = icmp eq i32 %389, %12
br i1 %390, label %391, label %411
391: ; preds = %388
%392 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %24, i32 %12)
%393 = icmp eq i32 %392, %12
br i1 %393, label %394, label %411
394: ; preds = %391
%395 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %12)
%396 = icmp eq i32 %395, %12
br i1 %396, label %397, label %411
397: ; preds = %394
%398 = urem i32 %24, %5
%399 = icmp ne i32 %31, %398
%400 = udiv i32 %10, %12
%401 = udiv i32 %5, %12
%402 = urem i32 %400, %401
%403 = udiv i32 %24, %12
%404 = urem i32 %403, %401
%405 = icmp eq i32 %402, %404
%406 = xor i1 %399, %405
br i1 %406, label %411, label %407
407: ; preds = %397
%408 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 21, i32 %4)
%409 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%410 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
411: ; preds = %397, %394, %391, %388, %387
br i1 %82, label %434, label %412
412: ; preds = %411
%413 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %10, i32 %30)
%414 = icmp eq i32 %413, %30
br i1 %414, label %415, label %434
415: ; preds = %412
%416 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %11, i32 %30)
%417 = icmp eq i32 %416, %30
br i1 %417, label %418, label %434
418: ; preds = %415
%419 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %30)
%420 = icmp eq i32 %419, %30
br i1 %420, label %421, label %434
421: ; preds = %418
%422 = icmp ne i32 %31, %32
%423 = udiv i32 %10, %30
%424 = udiv i32 %5, %30
%425 = urem i32 %423, %424
%426 = udiv i32 %11, %30
%427 = urem i32 %426, %424
%428 = icmp eq i32 %425, %427
%429 = xor i1 %422, %428
br i1 %429, label %434, label %430
430: ; preds = %421
%431 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 22, i32 %4)
%432 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%433 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
434: ; preds = %421, %418, %415, %412, %411
br i1 %107, label %513, label %435
435: ; preds = %434
%436 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %10, i32 %12)
%437 = icmp eq i32 %436, %12
br i1 %437, label %438, label %457
438: ; preds = %435
%439 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %11, i32 %12)
%440 = icmp eq i32 %439, %12
br i1 %440, label %441, label %457
441: ; preds = %438
%442 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %12)
%443 = icmp eq i32 %442, %12
br i1 %443, label %444, label %457
444: ; preds = %441
%445 = icmp ne i32 %31, %32
%446 = udiv i32 %10, %12
%447 = udiv i32 %5, %12
%448 = urem i32 %446, %447
%449 = udiv i32 %11, %12
%450 = urem i32 %449, %447
%451 = icmp eq i32 %448, %450
%452 = xor i1 %445, %451
br i1 %452, label %457, label %453
453: ; preds = %444
%454 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 23, i32 %4)
%455 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%456 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
457: ; preds = %435, %438, %441, %444
%458 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %12)
%459 = icmp eq i32 %458, %12
br i1 %459, label %460, label %472
460: ; preds = %457
%461 = urem i32 %18, %5
%462 = urem i32 %24, %5
%463 = icmp ne i32 %461, %462
%464 = urem i32 %18, %12
%465 = urem i32 %24, %12
%466 = icmp eq i32 %464, %465
%467 = xor i1 %463, %466
br i1 %467, label %472, label %468
468: ; preds = %460
%469 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 25, i32 %4)
%470 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%471 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
472: ; preds = %457, %460
%473 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %12)
%474 = icmp eq i32 %473, %12
br i1 %474, label %475, label %486
475: ; preds = %472
%476 = urem i32 %18, %5
%477 = icmp ne i32 %476, %32
%478 = urem i32 %18, %12
%479 = urem i32 %11, %12
%480 = icmp eq i32 %478, %479
%481 = xor i1 %477, %480
br i1 %481, label %486, label %482
482: ; preds = %475
%483 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 27, i32 %4)
%484 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%485 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
486: ; preds = %472, %475
%487 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %12)
%488 = icmp eq i32 %487, %12
br i1 %488, label %489, label %500
489: ; preds = %486
%490 = urem i32 %24, %5
%491 = icmp ne i32 %31, %490
%492 = urem i32 %10, %12
%493 = urem i32 %24, %12
%494 = icmp eq i32 %492, %493
%495 = xor i1 %491, %494
br i1 %495, label %500, label %496
496: ; preds = %489
%497 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 29, i32 %4)
%498 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%499 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
500: ; preds = %486, %489
%501 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %5, i32 %12)
%502 = icmp eq i32 %501, %12
br i1 %502, label %503, label %513
503: ; preds = %500
%504 = icmp ne i32 %31, %32
%505 = urem i32 %10, %12
%506 = urem i32 %11, %12
%507 = icmp eq i32 %505, %506
%508 = xor i1 %504, %507
br i1 %508, label %513, label %509
509: ; preds = %503
%510 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 31, i32 %4)
%511 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.30, i64 0, i64 0))
%512 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %5, i32 %10, i32 %11, i32 %12, i32 %18, i32 %24, i32 %30)
br label %519
513: ; preds = %7, %500, %503, %434
%514 = phi i32 [ %8, %7 ], [ %4, %500 ], [ %4, %503 ], [ %4, %434 ]
%515 = add nsw i32 %514, 1
%516 = icmp ult i32 %515, 100
br i1 %516, label %3, label %517
517: ; preds = %513
%518 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str, i64 0, i64 0))
br label %519
519: ; preds = %42, %61, %75, %100, %125, %148, %171, %194, %217, %239, %261, %286, %311, %335, %359, %383, %407, %430, %453, %468, %482, %496, %509, %517
%520 = phi i32 [ 0, %517 ], [ 1, %509 ], [ 1, %496 ], [ 1, %482 ], [ 1, %468 ], [ 1, %453 ], [ 1, %430 ], [ 1, %407 ], [ 1, %383 ], [ 1, %359 ], [ 1, %335 ], [ 1, %311 ], [ 1, %286 ], [ 1, %261 ], [ 1, %239 ], [ 1, %217 ], [ 1, %194 ], [ 1, %171 ], [ 1, %148 ], [ 1, %125 ], [ 1, %100 ], [ 1, %75 ], [ 1, %61 ], [ 1, %42 ]
ret i32 %520
}