#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int gcd(int, int);
int /*<<< orphan*/ printf(char *, ...);
void print_gcd(char s1[], char s2[], int n1, int n2) {
  if (n1 * n2 == 0) {
    return;
  }
  if (n1 == n2) {
    int j;
    for (j = 0; (s1[j] == s2[j]) && (j < n1); j++) {
      ;
    }
    if (j == n1) {
      printf("%s", s1);
    } else
      return;
  }
  if (n1 < n2) {
    if (n2 % n1 == 0) {
      int i, j;
      for (i = 0; i < n1 / n2; i++) {
        for (j = 0; (j < n1) && (s1[j] == s2[n1 * i + j]); j++) {
          ;
        }
        if (j != n1)
          return;
      }
      printf("%s", s1);
    }
    if (n2 % n1 != 0) {
      int i, j, k;
      for (i = 1; i < n1 / gcd(n2, n1); i++) {
        for (j = 0; (s1[j] == s1[gcd(n2, n1) * i + j]) && (j < gcd(n2, n1));
             j++) {
          ;
        }
        if (j != gcd(n2, n1))
          return;
      }
      for (i = 1; i < n2 / gcd(n2, n1); i++) {
        for (j = 0; (j < gcd(n2, n1)) && (s2[j] == s2[gcd(n2, n1) * i + j]);
             j++) {
          ;
        }
        if (j != gcd(n2, n1))
          return;
      }
      for (k = 0; (k < gcd(n2, n1)) && (s1[k] == s2[k]); k++) {
        ;
      }
      if (k != gcd(n2, n1))
        return;
      else {
        for (int i = 0; i < gcd(n2, n1); i++) {
          printf("%c", s1[i]);
        }
      }
    }
  }
  if (n2 < n1) {
    return print_gcd(s2, s1, n2, n1);
  }
}


x86 assembly (clang, -O0):
<print_gcd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cmp    $0x0,%eax
jne    115e <print_gcd+0x2e>
jmp    15f3 <print_gcd+0x4c3>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    11f2 <print_gcd+0xc2>
movl   $0x0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rdx
movsbl (%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x35(%rbp)
jne    11a2 <print_gcd+0x72>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    11b2 <print_gcd+0x82>
jmp    11c5 <print_gcd+0x95>
jmp    11b7 <print_gcd+0x87>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1171 <print_gcd+0x41>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    11e8 <print_gcd+0xb8>
mov    -0x8(%rbp),%rsi
lea    0xe24(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    11ed <print_gcd+0xbd>
jmp    15f3 <print_gcd+0x4c3>
jmp    11f2 <print_gcd+0xc2>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15d4 <print_gcd+0x4a4>
mov    -0x18(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cmp    $0x0,%edx
jne    12c9 <print_gcd+0x199>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x14(%rbp),%eax
cltd
idivl  -0x18(%rbp)
mov    %eax,%ecx
mov    -0x3c(%rbp),%eax
cmp    %ecx,%eax
jge    12b7 <print_gcd+0x187>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x3d(%rbp)
jge    1270 <print_gcd+0x140>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
imul   -0x20(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    1280 <print_gcd+0x150>
jmp    1293 <print_gcd+0x163>
jmp    1285 <print_gcd+0x155>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1236 <print_gcd+0x106>
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     12a4 <print_gcd+0x174>
jmp    15f3 <print_gcd+0x4c3>
jmp    12a9 <print_gcd+0x179>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1215 <print_gcd+0xe5>
mov    -0x8(%rbp),%rsi
lea    0xd3e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cmp    $0x0,%edx
je     15cf <print_gcd+0x49f>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
cmp    %ecx,%eax
jge    13d0 <print_gcd+0x2a0>
movl   $0x0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    -0x5c(%rbp),%ecx
mov    %eax,%edx
mov    -0x58(%rbp),%rax
imul   -0x28(%rbp),%edx
add    -0x2c(%rbp),%edx
movslq %edx,%rdx
movsbl (%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x49(%rbp)
jne    1377 <print_gcd+0x247>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    -0x60(%rbp),%eax
cmp    %ecx,%eax
setl   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    1387 <print_gcd+0x257>
jmp    139a <print_gcd+0x26a>
jmp    138c <print_gcd+0x25c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1313 <print_gcd+0x1e3>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
cmp    %ecx,%eax
je     13bd <print_gcd+0x28d>
jmp    15f3 <print_gcd+0x4c3>
jmp    13c2 <print_gcd+0x292>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12e0 <print_gcd+0x1b0>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    -0x6c(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x68(%rbp),%eax
cmp    %ecx,%eax
jge    14cd <print_gcd+0x39d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    -0x74(%rbp),%ecx
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x6d(%rbp)
jge    146e <print_gcd+0x33e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    -0x80(%rbp),%rcx
mov    %eax,%edx
mov    -0x78(%rbp),%eax
imul   -0x28(%rbp),%edx
add    -0x2c(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x6d(%rbp)
mov    -0x6d(%rbp),%al
test   $0x1,%al
jne    147e <print_gcd+0x34e>
jmp    1491 <print_gcd+0x361>
jmp    1483 <print_gcd+0x353>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    140a <print_gcd+0x2da>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
cmp    %ecx,%eax
je     14ba <print_gcd+0x38a>
jmp    15f3 <print_gcd+0x4c3>
jmp    14bf <print_gcd+0x38f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13d7 <print_gcd+0x2a7>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    -0x8c(%rbp),%ecx
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x85(%rbp)
jge    1523 <print_gcd+0x3f3>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x85(%rbp)
mov    -0x85(%rbp),%al
test   $0x1,%al
jne    1536 <print_gcd+0x406>
jmp    1549 <print_gcd+0x419>
jmp    153b <print_gcd+0x40b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14d4 <print_gcd+0x3a4>
mov    -0x30(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    -0x90(%rbp),%eax
cmp    %ecx,%eax
je     1572 <print_gcd+0x442>
jmp    15f3 <print_gcd+0x4c3>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
cmp    %ecx,%eax
jge    15c5 <print_gcd+0x495>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xa53(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1579 <print_gcd+0x449>
jmp    15ca <print_gcd+0x49a>
jmp    15cf <print_gcd+0x49f>
jmp    15d4 <print_gcd+0x4a4>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15f3 <print_gcd+0x4c3>
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x18(%rbp),%edx
mov    -0x14(%rbp),%ecx
call   1040 <print_gcd@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_gcd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,0x8(%rsp)
mov    %ecx,%eax
imul   %edx,%eax
test   %eax,%eax
je     147a <print_gcd+0x34a>
mov    %edx,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%rsp),%r12
mov    %rsi,0x8(%rsp)
mov    %r13d,%r14d
mov    %ecx,%r13d
cmp    %ecx,%r14d
jne    11b8 <print_gcd+0x88>
movslq %r13d,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl (%r12,%rdx,1),%ebx
lea    0x1(%rdx),%rcx
mov    0x8(%rsp),%rsi
cmp    (%rsi,%rdx,1),%bl
jne    119b <print_gcd+0x6b>
cmp    %rax,%rdx
mov    %rcx,%rdx
jl     1180 <print_gcd+0x50>
lea    0x1(%r13),%eax
cmp    %ecx,%eax
jne    147a <print_gcd+0x34a>
lea    0xe52(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmp    %r13d,%r14d
jge    1460 <print_gcd+0x330>
mov    %r13d,%eax
cltd
idiv   %r14d
test   %edx,%edx
je     13f2 <print_gcd+0x2c2>
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    %r14d,%eax
cltd
idiv   %ecx
cmp    $0x2,%eax
jl     12a2 <print_gcd+0x172>
mov    $0x1,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r12),%bpl
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
imul   %r15d,%eax
cltq
xor    %ebx,%ebx
cmp    (%r12,%rax,1),%bpl
jne    126f <print_gcd+0x13f>
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rbp),%rbx
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
cltq
cmp    %rax,%rbx
jge    126f <print_gcd+0x13f>
movzbl (%r12,%rbp,1),%ebx
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
imul   %r15d,%eax
add    %ebp,%eax
cltq
add    $0x1,%rbp
cmp    (%r12,%rax,1),%bl
je     1230 <print_gcd+0x100>
add    $0xffffffffffffffff,%rbp
mov    %rbp,%rbx
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
cmp    %eax,%ebx
jne    147a <print_gcd+0x34a>
add    $0x1,%r15d
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    %r14d,%eax
cltd
idiv   %ecx
cmp    %eax,%r15d
jl     1200 <print_gcd+0xd0>
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    %r13d,%eax
cltd
idiv   %ecx
cmp    $0x2,%eax
jl     1360 <print_gcd+0x230>
mov    $0x1,%ebp
mov    %r12,0x10(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
xor    %r15d,%r15d
test   %eax,%eax
jle    132e <print_gcd+0x1fe>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%r12
movzbl (%r12,%r15,1),%ebx
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
imul   %ebp,%eax
add    %r15d,%eax
cltq
cmp    (%r12,%rax,1),%bl
jne    1329 <print_gcd+0x1f9>
add    $0x1,%r15
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
cltq
cmp    %rax,%r15
jl     12f0 <print_gcd+0x1c0>
mov    0x10(%rsp),%r12
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
cmp    %eax,%r15d
jne    147a <print_gcd+0x34a>
add    $0x1,%ebp
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
mov    %eax,%ecx
mov    %r13d,%eax
cltd
idiv   %ecx
cmp    %eax,%ebp
jl     12d0 <print_gcd+0x1a0>
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
xor    %ebx,%ebx
test   %eax,%eax
jle    13a5 <print_gcd+0x275>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rbx,1),%eax
mov    0x8(%rsp),%rcx
cmp    (%rcx,%rbx,1),%al
jne    13a5 <print_gcd+0x275>
add    $0x1,%rbx
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
cltq
cmp    %rax,%rbx
jl     1380 <print_gcd+0x250>
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
cmp    %eax,%ebx
jne    147a <print_gcd+0x34a>
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
test   %eax,%eax
jle    1460 <print_gcd+0x330>
xor    %ebx,%ebx
nopl   (%rax)
movsbl (%r12,%rbx,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
mov    %r13d,%edi
mov    %r14d,%esi
call   1050 <gcd@plt>
cltq
cmp    %rax,%rbx
jl     13d0 <print_gcd+0x2a0>
jmp    1460 <print_gcd+0x330>
mov    %r14d,%eax
cltd
idiv   %r13d
test   %eax,%eax
jle    1445 <print_gcd+0x315>
movslq %r14d,%r8
mov    %eax,%eax
mov    %r14d,%edx
mov    $0x1,%bl
mov    0x8(%rsp),%rsi
xor    %edi,%edi
jmp    1427 <print_gcd+0x2f7>
cmp    %r14d,%ebp
jne    1458 <print_gcd+0x328>
add    $0x1,%rdi
cmp    %rax,%rdi
setb   %bl
add    %r8,%rsi
cmp    %rax,%rdi
je     1445 <print_gcd+0x315>
xor    %ebp,%ebp
test   %r14d,%r14d
jle    1410 <print_gcd+0x2e0>
xchg   %ax,%ax
movzbl (%r12,%rbp,1),%ecx
cmp    (%rsi,%rbp,1),%cl
jne    1410 <print_gcd+0x2e0>
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1430 <print_gcd+0x300>
jmp    1415 <print_gcd+0x2e5>
lea    0xbb4(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1460 <print_gcd+0x330>
test   $0x1,%bl
jne    147a <print_gcd+0x34a>
nopl   (%rax)
cmp    %r14d,%r13d
jge    147a <print_gcd+0x34a>
mov    %r14d,%eax
imul   %r13d,%eax
mov    %r14d,%ecx
mov    %r12,%rsi
test   %eax,%eax
jne    1160 <print_gcd+0x30>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%s\00"
@.str.1 = [3 x i8] c"%c\00"
define void @print_gcd(i8* %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%16 = load i32, i32* %7
%17 = load i32, i32* %8
%18 = mul nsw i32 %16, %17
%19 = icmp eq i32 %18, 0
br i1 %19, label %20, label %21
20: ; preds = %4
br label %291
21: ; preds = %4
%22 = load i32, i32* %7
%23 = load i32, i32* %8
%24 = icmp eq i32 %22, %23
br i1 %24, label %25, label %59
25: ; preds = %21
store i32 0, i32* %9
br label %26
26: ; preds = %47, %25
%27 = load i8*, i8** %5
%28 = load i32, i32* %9
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i8, i8* %27, i64 %29
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = load i8*, i8** %6
%34 = load i32, i32* %9
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i8, i8* %33, i64 %35
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp eq i32 %32, %38
br i1 %39, label %40, label %44
40: ; preds = %26
%41 = load i32, i32* %9
%42 = load i32, i32* %7
%43 = icmp slt i32 %41, %42
br label %44
44: ; preds = %40, %26
%45 = phi i1 [ false, %26 ], [ %43, %40 ]
br i1 %45, label %46, label %50
46: ; preds = %44
br label %47
47: ; preds = %46
%48 = load i32, i32* %9
%49 = add nsw i32 %48, 1
store i32 %49, i32* %9
br label %26
50: ; preds = %44
%51 = load i32, i32* %9
%52 = load i32, i32* %7
%53 = icmp eq i32 %51, %52
br i1 %53, label %54, label %57
54: ; preds = %50
%55 = load i8*, i8** %5
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %55)
br label %58
57: ; preds = %50
br label %291
58: ; preds = %54
br label %59
59: ; preds = %58, %21
%60 = load i32, i32* %7
%61 = load i32, i32* %8
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %282
63: ; preds = %59
%64 = load i32, i32* %8
%65 = load i32, i32* %7
%66 = srem i32 %64, %65
%67 = icmp eq i32 %66, 0
br i1 %67, label %68, label %116
68: ; preds = %63
store i32 0, i32* %10
br label %69
69: ; preds = %110, %68
%70 = load i32, i32* %10
%71 = load i32, i32* %7
%72 = load i32, i32* %8
%73 = sdiv i32 %71, %72
%74 = icmp slt i32 %70, %73
br i1 %74, label %75, label %113
75: ; preds = %69
store i32 0, i32* %11
br label %76
76: ; preds = %101, %75
%77 = load i32, i32* %11
%78 = load i32, i32* %7
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %98
80: ; preds = %76
%81 = load i8*, i8** %5
%82 = load i32, i32* %11
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i8, i8* %81, i64 %83
%85 = load i8, i8* %84
%86 = sext i8 %85 to i32
%87 = load i8*, i8** %6
%88 = load i32, i32* %7
%89 = load i32, i32* %10
%90 = mul nsw i32 %88, %89
%91 = load i32, i32* %11
%92 = add nsw i32 %90, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %87, i64 %93
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = icmp eq i32 %86, %96
br label %98
98: ; preds = %80, %76
%99 = phi i1 [ false, %76 ], [ %97, %80 ]
br i1 %99, label %100, label %104
100: ; preds = %98
br label %101
101: ; preds = %100
%102 = load i32, i32* %11
%103 = add nsw i32 %102, 1
store i32 %103, i32* %11
br label %76
104: ; preds = %98
%105 = load i32, i32* %11
%106 = load i32, i32* %7
%107 = icmp ne i32 %105, %106
br i1 %107, label %108, label %109
108: ; preds = %104
br label %291
109: ; preds = %104
br label %110
110: ; preds = %109
%111 = load i32, i32* %10
%112 = add nsw i32 %111, 1
store i32 %112, i32* %10
br label %69
113: ; preds = %69
%114 = load i8*, i8** %5
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %114)
br label %116
116: ; preds = %113, %63
%117 = load i32, i32* %8
%118 = load i32, i32* %7
%119 = srem i32 %117, %118
%120 = icmp ne i32 %119, 0
br i1 %120, label %121, label %281
121: ; preds = %116
store i32 1, i32* %12
br label %122
122: ; preds = %171, %121
%123 = load i32, i32* %12
%124 = load i32, i32* %7
%125 = load i32, i32* %8
%126 = load i32, i32* %7
%127 = call i32 @gcd(i32 %125, i32 %126)
%128 = sdiv i32 %124, %127
%129 = icmp slt i32 %123, %128
br i1 %129, label %130, label %174
130: ; preds = %122
store i32 0, i32* %13
br label %131
131: ; preds = %160, %130
%132 = load i8*, i8** %5
%133 = load i32, i32* %13
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i8, i8* %132, i64 %134
%136 = load i8, i8* %135
%137 = sext i8 %136 to i32
%138 = load i8*, i8** %5
%139 = load i32, i32* %8
%140 = load i32, i32* %7
%141 = call i32 @gcd(i32 %139, i32 %140)
%142 = load i32, i32* %12
%143 = mul nsw i32 %141, %142
%144 = load i32, i32* %13
%145 = add nsw i32 %143, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i8, i8* %138, i64 %146
%148 = load i8, i8* %147
%149 = sext i8 %148 to i32
%150 = icmp eq i32 %137, %149
br i1 %150, label %151, label %157
151: ; preds = %131
%152 = load i32, i32* %13
%153 = load i32, i32* %8
%154 = load i32, i32* %7
%155 = call i32 @gcd(i32 %153, i32 %154)
%156 = icmp slt i32 %152, %155
br label %157
157: ; preds = %151, %131
%158 = phi i1 [ false, %131 ], [ %156, %151 ]
br i1 %158, label %159, label %163
159: ; preds = %157
br label %160
160: ; preds = %159
%161 = load i32, i32* %13
%162 = add nsw i32 %161, 1
store i32 %162, i32* %13
br label %131
163: ; preds = %157
%164 = load i32, i32* %13
%165 = load i32, i32* %8
%166 = load i32, i32* %7
%167 = call i32 @gcd(i32 %165, i32 %166)
%168 = icmp ne i32 %164, %167
br i1 %168, label %169, label %170
169: ; preds = %163
br label %291
170: ; preds = %163
br label %171
171: ; preds = %170
%172 = load i32, i32* %12
%173 = add nsw i32 %172, 1
store i32 %173, i32* %12
br label %122
174: ; preds = %122
store i32 1, i32* %12
br label %175
175: ; preds = %224, %174
%176 = load i32, i32* %12
%177 = load i32, i32* %8
%178 = load i32, i32* %8
%179 = load i32, i32* %7
%180 = call i32 @gcd(i32 %178, i32 %179)
%181 = sdiv i32 %177, %180
%182 = icmp slt i32 %176, %181
br i1 %182, label %183, label %227
183: ; preds = %175
store i32 0, i32* %13
br label %184
184: ; preds = %213, %183
%185 = load i32, i32* %13
%186 = load i32, i32* %8
%187 = load i32, i32* %7
%188 = call i32 @gcd(i32 %186, i32 %187)
%189 = icmp slt i32 %185, %188
br i1 %189, label %190, label %210
190: ; preds = %184
%191 = load i8*, i8** %6
%192 = load i32, i32* %13
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %191, i64 %193
%195 = load i8, i8* %194
%196 = sext i8 %195 to i32
%197 = load i8*, i8** %6
%198 = load i32, i32* %8
%199 = load i32, i32* %7
%200 = call i32 @gcd(i32 %198, i32 %199)
%201 = load i32, i32* %12
%202 = mul nsw i32 %200, %201
%203 = load i32, i32* %13
%204 = add nsw i32 %202, %203
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i8, i8* %197, i64 %205
%207 = load i8, i8* %206
%208 = sext i8 %207 to i32
%209 = icmp eq i32 %196, %208
br label %210
210: ; preds = %190, %184
%211 = phi i1 [ false, %184 ], [ %209, %190 ]
br i1 %211, label %212, label %216
212: ; preds = %210
br label %213
213: ; preds = %212
%214 = load i32, i32* %13
%215 = add nsw i32 %214, 1
store i32 %215, i32* %13
br label %184
216: ; preds = %210
%217 = load i32, i32* %13
%218 = load i32, i32* %8
%219 = load i32, i32* %7
%220 = call i32 @gcd(i32 %218, i32 %219)
%221 = icmp ne i32 %217, %220
br i1 %221, label %222, label %223
222: ; preds = %216
br label %291
223: ; preds = %216
br label %224
224: ; preds = %223
%225 = load i32, i32* %12
%226 = add nsw i32 %225, 1
store i32 %226, i32* %12
br label %175
227: ; preds = %175
store i32 0, i32* %14
br label %228
228: ; preds = %251, %227
%229 = load i32, i32* %14
%230 = load i32, i32* %8
%231 = load i32, i32* %7
%232 = call i32 @gcd(i32 %230, i32 %231)
%233 = icmp slt i32 %229, %232
br i1 %233, label %234, label %248
234: ; preds = %228
%235 = load i8*, i8** %5
%236 = load i32, i32* %14
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i8, i8* %235, i64 %237
%239 = load i8, i8* %238
%240 = sext i8 %239 to i32
%241 = load i8*, i8** %6
%242 = load i32, i32* %14
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i8, i8* %241, i64 %243
%245 = load i8, i8* %244
%246 = sext i8 %245 to i32
%247 = icmp eq i32 %240, %246
br label %248
248: ; preds = %234, %228
%249 = phi i1 [ false, %228 ], [ %247, %234 ]
br i1 %249, label %250, label %254
250: ; preds = %248
br label %251
251: ; preds = %250
%252 = load i32, i32* %14
%253 = add nsw i32 %252, 1
store i32 %253, i32* %14
br label %228
254: ; preds = %248
%255 = load i32, i32* %14
%256 = load i32, i32* %8
%257 = load i32, i32* %7
%258 = call i32 @gcd(i32 %256, i32 %257)
%259 = icmp ne i32 %255, %258
br i1 %259, label %260, label %261
260: ; preds = %254
br label %291
261: ; preds = %254
store i32 0, i32* %15
br label %262
262: ; preds = %276, %261
%263 = load i32, i32* %15
%264 = load i32, i32* %8
%265 = load i32, i32* %7
%266 = call i32 @gcd(i32 %264, i32 %265)
%267 = icmp slt i32 %263, %266
br i1 %267, label %268, label %279
268: ; preds = %262
%269 = load i8*, i8** %5
%270 = load i32, i32* %15
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i8, i8* %269, i64 %271
%273 = load i8, i8* %272
%274 = sext i8 %273 to i32
%275 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %274)
br label %276
276: ; preds = %268
%277 = load i32, i32* %15
%278 = add nsw i32 %277, 1
store i32 %278, i32* %15
br label %262
279: ; preds = %262
br label %280
280: ; preds = %279
br label %281
281: ; preds = %280, %116
br label %282
282: ; preds = %281, %59
%283 = load i32, i32* %8
%284 = load i32, i32* %7
%285 = icmp slt i32 %283, %284
br i1 %285, label %286, label %291
286: ; preds = %282
%287 = load i8*, i8** %6
%288 = load i8*, i8** %5
%289 = load i32, i32* %8
%290 = load i32, i32* %7
br label %291
291: ; preds = %20, %57, %108, %169, %222, %260, %286, %282
ret void
}

LLVM IR (-O2):
@.str = [3 x i8] c"%s\00"
define void @print_gcd(i8* %0, i8* %1, i32 %2, i32 %3) {
%5 = mul nsw i32 %3, %2
%6 = icmp eq i32 %5, 0
br i1 %6, label %196, label %7
7: ; preds = %4, %193
%8 = phi i32 [ %9, %193 ], [ %3, %4 ]
%9 = phi i32 [ %8, %193 ], [ %2, %4 ]
%10 = phi i8* [ %11, %193 ], [ %1, %4 ]
%11 = phi i8* [ %10, %193 ], [ %0, %4 ]
%12 = icmp eq i32 %9, %8
br i1 %12, label %13, label %30
13: ; preds = %7
%14 = sext i32 %8 to i64
br label %15
15: ; preds = %13, %15
%16 = phi i64 [ 0, %13 ], [ %24, %15 ]
%17 = getelementptr inbounds i8, i8* %11, i64 %16
%18 = load i8, i8* %17
%19 = getelementptr inbounds i8, i8* %10, i64 %16
%20 = load i8, i8* %19
%21 = icmp eq i8 %18, %20
%22 = icmp slt i64 %16, %14
%23 = select i1 %21, i1 %22, i1 false
%24 = add nuw nsw i64 %16, 1
br i1 %23, label %15, label %25
25: ; preds = %15
%26 = trunc i64 %16 to i32
%27 = icmp eq i32 %8, %26
br i1 %27, label %28, label %196
28: ; preds = %25
%29 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %11)
br label %30
30: ; preds = %28, %7
%31 = icmp slt i32 %9, %8
br i1 %31, label %32, label %191
32: ; preds = %30
%33 = srem i32 %8, %9
%34 = icmp eq i32 %33, 0
br i1 %34, label %35, label %75
35: ; preds = %32
%36 = sdiv i32 %9, %8
%37 = icmp sgt i32 %36, 0
br i1 %37, label %38, label %69
38: ; preds = %35
%39 = icmp sgt i32 %9, 0
%40 = sext i32 %9 to i64
%41 = zext i32 %36 to i64
%42 = zext i32 %36 to i64
%43 = zext i32 %9 to i64
br label %48
44: ; preds = %61, %66
%45 = add nuw nsw i64 %49, 1
%46 = icmp ult i64 %45, %41
%47 = icmp eq i64 %45, %42
br i1 %47, label %69, label %48
48: ; preds = %38, %44
%49 = phi i64 [ 0, %38 ], [ %45, %44 ]
%50 = phi i1 [ true, %38 ], [ %46, %44 ]
br i1 %39, label %51, label %66
51: ; preds = %48
%52 = mul nsw i64 %49, %40
br label %53
53: ; preds = %51, %61
%54 = phi i64 [ 0, %51 ], [ %62, %61 ]
%55 = getelementptr inbounds i8, i8* %11, i64 %54
%56 = load i8, i8* %55
%57 = add nsw i64 %54, %52
%58 = getelementptr inbounds i8, i8* %10, i64 %57
%59 = load i8, i8* %58
%60 = icmp eq i8 %56, %59
br i1 %60, label %61, label %64
61: ; preds = %53
%62 = add nuw nsw i64 %54, 1
%63 = icmp eq i64 %62, %43
br i1 %63, label %44, label %53
64: ; preds = %53
%65 = trunc i64 %54 to i32
br label %66
66: ; preds = %64, %48
%67 = phi i32 [ 0, %48 ], [ %65, %64 ]
%68 = icmp eq i32 %67, %9
br i1 %68, label %44, label %71
69: ; preds = %44, %35
%70 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %11)
br label %191
71: ; preds = %66
%72 = xor i1 %50, true
%73 = icmp slt i32 %8, %9
%74 = select i1 %72, i1 %73, i1 false
br i1 %74, label %193, label %196
75: ; preds = %32
%76 = tail call i32 @gcd(i32 %8, i32 %9)
%77 = sdiv i32 %9, %76
%78 = icmp sgt i32 %77, 1
br i1 %78, label %87, label %83
79: ; preds = %116
%80 = tail call i32 @gcd(i32 %8, i32 %9)
%81 = sdiv i32 %9, %80
%82 = icmp slt i32 %120, %81
br i1 %82, label %87, label %83
83: ; preds = %79, %75
%84 = tail call i32 @gcd(i32 %8, i32 %9)
%85 = sdiv i32 %8, %84
%86 = icmp sgt i32 %85, 1
br i1 %86, label %128, label %125
87: ; preds = %75, %79
%88 = phi i32 [ %120, %79 ], [ 1, %75 ]
%89 = load i8, i8* %11
%90 = tail call i32 @gcd(i32 %8, i32 %9)
%91 = mul nsw i32 %90, %88
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %11, i64 %92
%94 = load i8, i8* %93
%95 = icmp eq i8 %89, %94
br i1 %95, label %96, label %116
96: ; preds = %87, %101
%97 = phi i64 [ %102, %101 ], [ 0, %87 ]
%98 = tail call i32 @gcd(i32 %8, i32 %9)
%99 = sext i32 %98 to i64
%100 = icmp slt i64 %97, %99
br i1 %100, label %101, label %113
101: ; preds = %96
%102 = add nuw nsw i64 %97, 1
%103 = trunc i64 %102 to i32
%104 = getelementptr inbounds i8, i8* %11, i64 %102
%105 = load i8, i8* %104
%106 = tail call i32 @gcd(i32 %8, i32 %9)
%107 = mul nsw i32 %106, %88
%108 = add nsw i32 %107, %103
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %11, i64 %109
%111 = load i8, i8* %110
%112 = icmp eq i8 %105, %111
br i1 %112, label %96, label %113
113: ; preds = %96, %101
%114 = phi i64 [ %102, %101 ], [ %97, %96 ]
%115 = trunc i64 %114 to i32
br label %116
116: ; preds = %113, %87
%117 = phi i32 [ 0, %87 ], [ %115, %113 ]
%118 = tail call i32 @gcd(i32 %8, i32 %9)
%119 = icmp eq i32 %117, %118
%120 = add nuw nsw i32 %88, 1
br i1 %119, label %79, label %196
121: ; preds = %152
%122 = tail call i32 @gcd(i32 %8, i32 %9)
%123 = sdiv i32 %8, %122
%124 = icmp slt i32 %156, %123
br i1 %124, label %128, label %125
125: ; preds = %121, %83
%126 = tail call i32 @gcd(i32 %8, i32 %9)
%127 = icmp sgt i32 %126, 0
br i1 %127, label %157, label %172
128: ; preds = %83, %121
%129 = phi i32 [ %156, %121 ], [ 1, %83 ]
%130 = tail call i32 @gcd(i32 %8, i32 %9)
%131 = icmp sgt i32 %130, 0
br i1 %131, label %132, label %152
132: ; preds = %128, %144
%133 = phi i64 [ %145, %144 ], [ 0, %128 ]
%134 = getelementptr inbounds i8, i8* %10, i64 %133
%135 = load i8, i8* %134
%136 = tail call i32 @gcd(i32 %8, i32 %9)
%137 = mul nsw i32 %136, %129
%138 = trunc i64 %133 to i32
%139 = add nsw i32 %137, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i8, i8* %10, i64 %140
%142 = load i8, i8* %141
%143 = icmp eq i8 %135, %142
br i1 %143, label %144, label %149
144: ; preds = %132
%145 = add nuw nsw i64 %133, 1
%146 = tail call i32 @gcd(i32 %8, i32 %9)
%147 = sext i32 %146 to i64
%148 = icmp slt i64 %145, %147
br i1 %148, label %132, label %149
149: ; preds = %132, %144
%150 = phi i64 [ %145, %144 ], [ %133, %132 ]
%151 = trunc i64 %150 to i32
br label %152
152: ; preds = %149, %128
%153 = phi i32 [ 0, %128 ], [ %151, %149 ]
%154 = tail call i32 @gcd(i32 %8, i32 %9)
%155 = icmp eq i32 %153, %154
%156 = add nuw nsw i32 %129, 1
br i1 %155, label %121, label %196
157: ; preds = %125, %164
%158 = phi i64 [ %165, %164 ], [ 0, %125 ]
%159 = getelementptr inbounds i8, i8* %11, i64 %158
%160 = load i8, i8* %159
%161 = getelementptr inbounds i8, i8* %10, i64 %158
%162 = load i8, i8* %161
%163 = icmp eq i8 %160, %162
br i1 %163, label %164, label %169
164: ; preds = %157
%165 = add nuw nsw i64 %158, 1
%166 = tail call i32 @gcd(i32 %8, i32 %9)
%167 = sext i32 %166 to i64
%168 = icmp slt i64 %165, %167
br i1 %168, label %157, label %169
169: ; preds = %164, %157
%170 = phi i64 [ %158, %157 ], [ %165, %164 ]
%171 = trunc i64 %170 to i32
br label %172
172: ; preds = %169, %125
%173 = phi i32 [ 0, %125 ], [ %171, %169 ]
%174 = tail call i32 @gcd(i32 %8, i32 %9)
%175 = icmp eq i32 %173, %174
br i1 %175, label %176, label %196
176: ; preds = %172
%177 = tail call i32 @gcd(i32 %8, i32 %9)
%178 = icmp sgt i32 %177, 0
br i1 %178, label %179, label %189
179: ; preds = %176, %179
%180 = phi i64 [ %185, %179 ], [ 0, %176 ]
%181 = getelementptr inbounds i8, i8* %11, i64 %180
%182 = load i8, i8* %181
%183 = sext i8 %182 to i32
%184 = tail call i32 @putchar(i32 %183)
%185 = add nuw nsw i64 %180, 1
%186 = tail call i32 @gcd(i32 %8, i32 %9)
%187 = sext i32 %186 to i64
%188 = icmp slt i64 %185, %187
br i1 %188, label %179, label %189
189: ; preds = %179, %176
%190 = icmp slt i32 %8, %9
br i1 %190, label %193, label %196
191: ; preds = %69, %30
%192 = icmp slt i32 %8, %9
br i1 %192, label %193, label %196
193: ; preds = %71, %189, %191
%194 = mul nsw i32 %9, %8
%195 = icmp eq i32 %194, 0
br i1 %195, label %196, label %7
196: ; preds = %191, %193, %71, %189, %172, %25, %116, %152, %4
ret void
}