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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ izracun(char, char **, int, int, int *, int, int, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  int i, j, sirina, visina, M = 0, P = 0, G = 0, tmpM = 0, tmpP = 0, tmpG = 0,
                            br_ukupno = 0, br_podjela = 0;
  char imanje[100][100] = {{0}};
  scanf("%d%d", &visina, &sirina);
  for (i = 0; i < visina; i++) {
    for (j = 0; j < sirina; j++) {
      scanf(" %c", &imanje[i][j]);
    }
  }
  for (i = 0; i < visina; i++) {
    for (j = 0; j < sirina; j++) {
      if (imanje[i][j] == 'M')
        M++;
      if (imanje[i][j] == 'P')
        P++;
      if (imanje[i][j] == 'G')
        G++;
    }
  }
  for (i = 0; i < visina; i++) {
    for (j = 0; j < sirina; j++) {
      if (imanje[i][j] == 'M')
        tmpM++;
      if (imanje[i][j] == 'P')
        tmpP++;
      if (imanje[i][j] == 'G')
        tmpG++;
    }
    if (tmpM == M / 2 && tmpP == P / 2 && tmpG == G / 2) {
      br_ukupno++;
    }
  }
  tmpM = tmpP = tmpG = 0;
  for (i = 0; i < sirina; i++) {
    for (j = 0; j < visina; j++) {
      if (imanje[j][i] == 'M')
        tmpM++;
      if (imanje[j][i] == 'P')
        tmpP++;
      if (imanje[j][i] == 'G')
        tmpG++;
    }
    if (tmpM == M / 2 && tmpP == P / 2 && tmpG == G / 2) {
      br_ukupno++;
    }
  }
  if (br_ukupno == 0) {
    printf("Nemoguce podijeliti 50-50.");
    return 0;
  } else {
    printf("Broj mogucih podjela: %d\n", br_ukupno);
    izracun('V', imanje, visina, sirina, &br_podjela, M, P, G);
    izracun('O', imanje, visina, sirina, &br_podjela, M, P, G);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2780,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
lea    -0x2750(%rbp),%rdi
xor    %esi,%esi
mov    $0x2710,%edx
call   1040 <memset@plt>
lea    0xe5c(%rip),%rdi
lea    -0x14(%rbp),%rsi
lea    -0x10(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1221 <main+0xe1>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    120e <main+0xce>
movslq -0x8(%rbp),%rax
lea    -0x2750(%rbp),%rsi
imul   $0x64,%rax,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
add    %rax,%rsi
lea    0xe0c(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11cd <main+0x8d>
jmp    1213 <main+0xd3>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11ba <main+0x7a>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12f1 <main+0x1b1>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12de <main+0x19e>
movslq -0x8(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4d,%eax
jne    1273 <main+0x133>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
movslq -0x8(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x50,%eax
jne    129f <main+0x15f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movslq -0x8(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x47,%eax
jne    12cb <main+0x18b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12d0 <main+0x190>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    123b <main+0xfb>
jmp    12e3 <main+0x1a3>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1228 <main+0xe8>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1436 <main+0x2f6>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13ae <main+0x26e>
movslq -0x8(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4d,%eax
jne    1343 <main+0x203>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movslq -0x8(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x50,%eax
jne    136f <main+0x22f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
movslq -0x8(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x47,%eax
jne    139b <main+0x25b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13a0 <main+0x260>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    130b <main+0x1cb>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2754(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2754(%rbp),%eax
cmp    %ecx,%eax
jne    1423 <main+0x2e3>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2758(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2758(%rbp),%eax
cmp    %ecx,%eax
jne    1423 <main+0x2e3>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x275c(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x275c(%rbp),%eax
cmp    %ecx,%eax
jne    1423 <main+0x2e3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1428 <main+0x2e8>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12f8 <main+0x1b8>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1590 <main+0x450>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1508 <main+0x3c8>
movslq -0xc(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4d,%eax
jne    149d <main+0x35d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movslq -0xc(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x50,%eax
jne    14c9 <main+0x389>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
movslq -0xc(%rbp),%rcx
lea    -0x2750(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x47,%eax
jne    14f5 <main+0x3b5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14fa <main+0x3ba>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1465 <main+0x325>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2760(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2760(%rbp),%eax
cmp    %ecx,%eax
jne    157d <main+0x43d>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2764(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2764(%rbp),%eax
cmp    %ecx,%eax
jne    157d <main+0x43d>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x2768(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2768(%rbp),%eax
cmp    %ecx,%eax
jne    157d <main+0x43d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1582 <main+0x442>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1452 <main+0x312>
cmpl   $0x0,-0x30(%rbp)
jne    15b4 <main+0x474>
lea    0xa68(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1628 <main+0x4e8>
mov    -0x30(%rbp),%esi
lea    0xa66(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x2750(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0x18(%rbp),%r9d
mov    -0x1c(%rbp),%r10d
mov    -0x20(%rbp),%eax
mov    $0x56,%edi
lea    -0x34(%rbp),%r8
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1060 <izracun@plt>
lea    -0x2750(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0x18(%rbp),%r9d
mov    -0x1c(%rbp),%r10d
mov    -0x20(%rbp),%eax
mov    $0x4f,%edi
lea    -0x34(%rbp),%r8
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1060 <izracun@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2780,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2778,%rsp
movl   $0x0,0x44(%rsp)
lea    0x60(%rsp),%r14
xor    %r15d,%r15d
mov    $0x2710,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    0xee9(%rip),%rdi
lea    0x14(%rsp),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0x14(%rsp),%edx
test   %edx,%edx
jle    147d <main+0x33d>
lea    0x60(%rsp),%rbp
mov    0xc(%rsp),%eax
lea    0xec1(%rip),%r13
xor    %r12d,%r12d
jmp    11c0 <main+0x80>
nopl   0x0(%rax)
add    $0x1,%r12
movslq %edx,%rcx
add    $0x64,%rbp
cmp    %rcx,%r12
jge    11f2 <main+0xb2>
test   %eax,%eax
jle    11b0 <main+0x70>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
lea    (%rbx,%rbp,1),%rsi
mov    %r13,%rdi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     11d0 <main+0x90>
mov    0x14(%rsp),%edx
jmp    11b0 <main+0x70>
test   %edx,%edx
jle    147d <main+0x33d>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x18(%rsp)
mov    0xc(%rsp),%ecx
mov    %edx,0x10(%rsp)
mov    %edx,%r12d
mov    %ecx,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%r8
mov    %r8,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10,%r9
and    $0xfffffffffffffffe,%r9
lea    0x64(%rsp),%rdi
xorps  %xmm8,%xmm8
xor    %r13d,%r13d
lea    0x60(%rsp),%rdx
movdqa 0xdf5(%rip),%xmm13
movdqa 0xdfd(%rip),%xmm1
movdqa 0xda4(%rip),%xmm10
movdqa 0xdac(%rip),%xmm3
movdqa 0xdb3(%rip),%xmm11
movdqa 0xdba(%rip),%xmm12
xor    %ebx,%ebx
xorps  %xmm2,%xmm2
jmp    1295 <main+0x155>
nopl   (%rax)
add    $0x1,%r13
add    $0x64,%rdi
add    $0x64,%rdx
cmp    %r12,%r13
je     1488 <main+0x348>
test   %ecx,%ecx
jle    1280 <main+0x140>
cmp    $0x4,%ecx
jae    12b0 <main+0x170>
xor    %eax,%eax
jmp    1430 <main+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm6,%xmm6
movss  %xmm2,%xmm6
shufps $0x11,%xmm8,%xmm2
shufps $0xe8,%xmm8,%xmm2
movd   %ebx,%xmm7
test   %r8,%r8
je     146c <main+0x32c>
mov    %r9,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   -0x4(%rdi,%rax,1),%xmm0
movdqa %xmm0,%xmm4
pcmpeqb %xmm10,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm7,%xmm4
movdqa %xmm0,%xmm5
pcmpeqb %xmm11,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm2,%xmm5
pcmpeqb %xmm12,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
paddd  %xmm6,%xmm0
movd   (%rdi,%rax,1),%xmm6
movdqa %xmm6,%xmm7
pcmpeqb %xmm10,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
pand   %xmm3,%xmm7
paddd  %xmm4,%xmm7
movdqa %xmm6,%xmm2
pcmpeqb %xmm11,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm5,%xmm2
pcmpeqb %xmm12,%xmm6
punpcklbw %xmm6,%xmm6
punpcklwd %xmm6,%xmm6
pand   %xmm3,%xmm6
paddd  %xmm0,%xmm6
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    12e0 <main+0x1a0>
test   $0x1,%r10b
je     13e4 <main+0x2a4>
imul   $0x64,%r13,%rbx
add    %rsp,%rbx
add    $0x60,%rbx
movd   (%rax,%rbx,1),%xmm0
movdqa %xmm0,%xmm4
pcmpeqb %xmm10,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm7
movdqa %xmm0,%xmm4
pcmpeqb %xmm11,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm2
pcmpeqb %xmm12,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
paddd  %xmm0,%xmm6
pshufd $0xee,%xmm7,%xmm0
paddd  %xmm7,%xmm0
pshufd $0x55,%xmm0,%xmm4
paddd  %xmm0,%xmm4
movd   %xmm4,%ebx
pshufd $0xee,%xmm2,%xmm0
paddd  %xmm2,%xmm0
pshufd $0x55,%xmm0,%xmm4
pshufd $0xee,%xmm6,%xmm2
paddd  %xmm6,%xmm2
pshufd $0x55,%xmm2,%xmm5
punpckldq %xmm4,%xmm5
punpckldq %xmm0,%xmm2
paddd  %xmm5,%xmm2
mov    %r11,%rax
cmp    %rcx,%r11
je     1280 <main+0x140>
xchg   %ax,%ax
movzbl (%rdx,%rax,1),%ebp
xor    %esi,%esi
cmp    $0x4d,%bpl
sete   %sil
add    %esi,%ebx
movd   %ebp,%xmm0
punpcklbw %xmm0,%xmm0
pcmpeqb %xmm13,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0xd4,%xmm0,%xmm0
pand   %xmm1,%xmm0
paddd  %xmm0,%xmm2
add    $0x1,%rax
cmp    %rax,%rcx
jne    1430 <main+0x2f0>
jmp    1280 <main+0x140>
xor    %eax,%eax
test   $0x1,%r10b
jne    138d <main+0x24d>
jmp    13e4 <main+0x2a4>
xor    %eax,%eax
xor    %ecx,%ecx
xor    %ebx,%ebx
jmp    1730 <main+0x5f0>
movd   %xmm2,%eax
pshufd $0x55,%xmm2,%xmm0
movd   %xmm0,%ecx
mov    0x10(%rsp),%edx
test   %edx,%edx
jle    1730 <main+0x5f0>
mov    %rcx,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    0xc(%rsp),%esi
mov    %ebx,%r13d
shr    $0x1f,%r13d
add    %ebx,%r13d
sar    %r13d
movdqa %xmm2,%xmm9
psrld  $0x1f,%xmm9
paddd  %xmm2,%xmm9
psrad  $0x1,%xmm9
mov    %esi,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%r10
mov    %r10,0x20(%rsp)
shr    $0x2,%r10
add    $0x1,%r10
and    %r10,0x18(%rsp)
lea    0x64(%rsp),%rcx
xorps  %xmm8,%xmm8
xor    %edi,%edi
lea    0x60(%rsp),%r8
xor    %r15d,%r15d
xor    %eax,%eax
pxor   %xmm7,%xmm7
jmp    154d <main+0x40d>
nopw   0x0(%rax,%rax,1)
cmp    %r13d,%eax
sete   %dl
movdqa %xmm7,%xmm0
pcmpeqd %xmm9,%xmm0
pshufd $0x50,%xmm0,%xmm0
movmskpd %xmm0,%ebp
and    %bpl,%dl
shr    %bpl
and    %dl,%bpl
movzbl %bpl,%edx
add    %edx,%r15d
add    $0x1,%rdi
add    $0x64,%rcx
add    $0x64,%r8
cmp    %r12,%rdi
je     173e <main+0x5fe>
test   %esi,%esi
jle    1510 <main+0x3d0>
cmp    $0x4,%esi
jae    1560 <main+0x420>
xor    %edx,%edx
jmp    16e0 <main+0x5a0>
nopl   (%rax)
pxor   %xmm6,%xmm6
movss  %xmm7,%xmm6
shufps $0x11,%xmm8,%xmm7
shufps $0xe8,%xmm8,%xmm7
movd   %eax,%xmm2
cmpq   $0x0,0x20(%rsp)
je     171f <main+0x5df>
mov    0x18(%rsp),%rdx
xor    %eax,%eax
nopl   0x0(%rax)
movd   -0x4(%rcx,%rax,1),%xmm4
movdqa %xmm4,%xmm0
pcmpeqb %xmm10,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
paddd  %xmm2,%xmm0
movdqa %xmm4,%xmm5
pcmpeqb %xmm11,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm7,%xmm5
pcmpeqb %xmm12,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm6,%xmm4
movd   (%rcx,%rax,1),%xmm6
movdqa %xmm6,%xmm2
pcmpeqb %xmm10,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqa %xmm6,%xmm7
pcmpeqb %xmm11,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
pand   %xmm3,%xmm7
paddd  %xmm5,%xmm7
pcmpeqb %xmm12,%xmm6
punpcklbw %xmm6,%xmm6
punpcklwd %xmm6,%xmm6
pand   %xmm3,%xmm6
paddd  %xmm4,%xmm6
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1590 <main+0x450>
test   $0x1,%r10b
je     1694 <main+0x554>
imul   $0x64,%rdi,%rdx
add    %rsp,%rdx
add    $0x60,%rdx
movd   (%rax,%rdx,1),%xmm0
movdqa %xmm0,%xmm4
pcmpeqb %xmm10,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm4
pcmpeqb %xmm11,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm7
pcmpeqb %xmm12,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
paddd  %xmm0,%xmm6
pshufd $0xee,%xmm2,%xmm0
paddd  %xmm2,%xmm0
pshufd $0x55,%xmm0,%xmm2
paddd  %xmm0,%xmm2
movd   %xmm2,%eax
pshufd $0xee,%xmm7,%xmm0
paddd  %xmm7,%xmm0
pshufd $0x55,%xmm0,%xmm2
pshufd $0xee,%xmm6,%xmm7
paddd  %xmm6,%xmm7
pshufd $0x55,%xmm7,%xmm4
punpckldq %xmm2,%xmm4
punpckldq %xmm0,%xmm7
paddd  %xmm4,%xmm7
mov    %r11,%rdx
cmp    %rsi,%r11
je     1510 <main+0x3d0>
xchg   %ax,%ax
movzbl (%r8,%rdx,1),%ebp
xor    %r9d,%r9d
cmp    $0x4d,%bpl
sete   %r9b
add    %r9d,%eax
movd   %ebp,%xmm0
punpcklbw %xmm0,%xmm0
pcmpeqb %xmm13,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0xd4,%xmm0,%xmm0
pand   %xmm1,%xmm0
paddd  %xmm0,%xmm7
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    16e0 <main+0x5a0>
jmp    1510 <main+0x3d0>
xor    %eax,%eax
test   $0x1,%r10b
jne    163d <main+0x4fd>
jmp    1694 <main+0x554>
mov    0xc(%rsp),%esi
movl   $0x0,0x20(%rsp)
jmp    1752 <main+0x612>
mov    $0x1,%al
mov    %eax,0x20(%rsp)
mov    0x10(%rsp),%edx
mov    0x30(%rsp),%rax
mov    0x28(%rsp),%rcx
test   %esi,%esi
mov    %rax,0x30(%rsp)
mov    %rcx,0x28(%rsp)
jle    1970 <main+0x830>
mov    %ebx,%edi
shr    $0x1f,%edi
add    %ebx,%edi
sar    %edi
mov    %edi,0x18(%rsp)
mov    %ecx,%edi
shr    $0x1f,%edi
add    %ecx,%edi
sar    %edi
mov    %edi,0x40(%rsp)
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
mov    %ecx,0x3c(%rsp)
mov    %esi,%eax
mov    %rax,0x58(%rsp)
mov    %edx,0x10(%rsp)
mov    %edx,%edx
mov    %edx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x50(%rsp)
lea    0x18c(%rsp),%rcx
mov    %rdx,0x48(%rsp)
shr    $0x2,%rdx
imul   $0x190,%rdx,%rsi
xor    %r13d,%r13d
movdqa 0x83a(%rip),%xmm8
movdqa 0x842(%rip),%xmm1
movdqa 0x84a(%rip),%xmm2
movdqa 0x852(%rip),%xmm3
xor    %r9d,%r9d
xor    %r12d,%r12d
xor    %edi,%edi
jmp    1828 <main+0x6e8>
nopl   0x0(%rax,%rax,1)
mov    %edi,%eax
xor    0x18(%rsp),%eax
mov    %r12d,%edx
xor    0x40(%rsp),%edx
or     %eax,%edx
mov    %r9d,%eax
xor    0x3c(%rsp),%eax
xor    %ebp,%ebp
or     %edx,%eax
sete   %bpl
add    %ebp,%r15d
add    $0x1,%r13
add    $0x1,%rcx
add    $0x1,%r14
cmp    0x58(%rsp),%r13
je     1970 <main+0x830>
cmpb   $0x0,0x20(%rsp)
je     17f0 <main+0x6b0>
cmpl   $0x4,0x10(%rsp)
jae    1840 <main+0x700>
xor    %r11d,%r11d
jmp    1924 <main+0x7e4>
xchg   %ax,%ax
movd   %r9d,%xmm4
movd   %r12d,%xmm5
movd   %edi,%xmm6
xor    %edi,%edi
movzbl -0x12c(%rcx,%rdi,1),%ebp
ff
movzbl -0x64(%rcx,%rdi,1),%eax
movzbl (%rcx,%rdi,1),%edx
shl    $0x8,%edx
or     %eax,%edx
movzbl -0xc8(%rcx,%rdi,1),%eax
ff
shl    $0x8,%eax
or     %ebp,%eax
movd   %eax,%xmm0
pinsrw $0x1,%edx,%xmm0
movdqa %xmm0,%xmm7
pcmpeqb %xmm8,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
pand   %xmm1,%xmm7
paddd  %xmm7,%xmm6
movdqa %xmm0,%xmm7
pcmpeqb %xmm2,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
pand   %xmm1,%xmm7
paddd  %xmm7,%xmm5
pcmpeqb %xmm3,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm1,%xmm0
paddd  %xmm0,%xmm4
add    $0x190,%rdi
cmp    %rdi,%rsi
jne    1850 <main+0x710>
pshufd $0xee,%xmm6,%xmm0
paddd  %xmm6,%xmm0
pshufd $0x55,%xmm0,%xmm6
paddd  %xmm0,%xmm6
movd   %xmm6,%edi
pshufd $0xee,%xmm5,%xmm0
paddd  %xmm5,%xmm0
pshufd $0x55,%xmm0,%xmm5
paddd  %xmm0,%xmm5
movd   %xmm5,%r12d
pshufd $0xee,%xmm4,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x55,%xmm0,%xmm4
paddd  %xmm0,%xmm4
movd   %xmm4,%r9d
mov    0x50(%rsp),%rax
mov    %rax,%r11
cmp    0x48(%rsp),%rax
je     17f0 <main+0x6b0>
imul   $0x64,%r11,%r8
add    %r14,%r8
mov    0x48(%rsp),%r10
sub    %r11,%r10
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%r8),%eax
xor    %edx,%edx
cmp    $0x4d,%al
sete   %dl
add    %edx,%edi
xor    %edx,%edx
cmp    $0x50,%al
sete   %dl
add    %edx,%r12d
xor    %edx,%edx
cmp    $0x47,%al
sete   %dl
add    %edx,%r9d
add    $0x64,%r8
add    $0xffffffffffffffff,%r10
jne    1940 <main+0x800>
jmp    17f0 <main+0x6b0>
test   %r15d,%r15d
je     19e0 <main+0x8a0>
lea    0x708(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <printf@plt>
mov    0x14(%rsp),%edx
mov    0xc(%rsp),%ecx
lea    0x60(%rsp),%r15
lea    0x44(%rsp),%r14
mov    $0x56,%edi
mov    %r15,%rsi
mov    %r14,%r8
mov    %ebx,%r9d
mov    0x30(%rsp),%rbp
push   %rbp
mov    0x30(%rsp),%r12
push   %r12
call   1060 <izracun@plt>
add    $0x10,%rsp
mov    0x14(%rsp),%edx
mov    0xc(%rsp),%ecx
mov    $0x4f,%edi
mov    %r15,%rsi
mov    %r14,%r8
mov    %ebx,%r9d
push   %rbp
push   %r12
call   1060 <izracun@plt>
add    $0x10,%rsp
jmp    19ee <main+0x8ae>
lea    0x682(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x2778,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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