#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*/ printf(char *, int);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int t, i, j, k, l, count = 0, d, sum = 0, n, c = 0;
  int a[100];
  scanf("%d", &n);
  scanf("%d", &k);
  for (i = 0; i < n; i++) {
    scanf("%d", &a[i]);
  }
  if (k == n) {
    for (i = 0; i < n; i++) {
      sum += a[i];
    }
  }
  if (k < n) {
    for (i = 0; i < n; i++) {
      for (j = 0; j < n - i - 1; j++) {
        if (a[j] > a[j + 1]) {
          d = a[j];
          a[j] = a[j + 1];
          a[j + 1] = d;
        }
      }
    }
    c = n / k;
    t = n % k;
    for (i = 0; i < c; i++) {
      for (j = n - i * k - 1; j > (n - k) - i * k - 1; j--) {
        sum += (i + 1) * a[j];
      }
    }
    for (j = 0; j < t; j++) {
      sum += (i + 1) * a[j];
    }
  }
  printf("%d\n", sum);
  sum = 0;
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
lea    0xeb2(%rip),%rdi
lea    -0x28(%rbp),%rsi
call   1040 <scanf@plt>
lea    0xea2(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1040 <scanf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11a6 <main+0x86>
movslq -0xc(%rbp),%rax
lea    -0x1c0(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe6d(%rip),%rdi
call   1040 <scanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    116e <main+0x4e>
mov    -0x14(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    11e9 <main+0xc9>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11e4 <main+0xc4>
movslq -0xc(%rbp),%rax
mov    -0x1c0(%rbp,%rax,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11b9 <main+0x99>
jmp    11e9 <main+0xc9>
mov    -0x14(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1371 <main+0x251>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12a4 <main+0x184>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1291 <main+0x171>
movslq -0x10(%rbp),%rax
mov    -0x1c0(%rbp,%rax,4),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    -0x1c0(%rbp,%rcx,4),%eax
jle    127e <main+0x15e>
movslq -0x10(%rbp),%rax
mov    -0x1c0(%rbp,%rax,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x1c0(%rbp,%rax,4),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x1c0(%rbp,%rax,4)
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x1c0(%rbp,%rax,4)
jmp    1283 <main+0x163>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    120f <main+0xef>
jmp    1296 <main+0x176>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11fc <main+0xdc>
mov    -0x28(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %edx,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1333 <main+0x213>
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    -0x14(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x14(%rbp),%edx
sub    %edx,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1320 <main+0x200>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
movslq -0x10(%rbp),%rcx
imul   -0x1c0(%rbp,%rcx,4),%eax
ff
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    12dd <main+0x1bd>
jmp    1325 <main+0x205>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12bf <main+0x19f>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    136c <main+0x24c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
movslq -0x10(%rbp),%rcx
imul   -0x1c0(%rbp,%rcx,4),%eax
ff
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    133a <main+0x21a>
jmp    1371 <main+0x251>
mov    -0x24(%rbp),%esi
lea    0xc88(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x24(%rbp)
xor    %eax,%eax
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
lea    0xec8(%rip),%rbx
mov    %rsp,%rsi
mov    %rbx,%rdi
call   1040 <scanf@plt>
lea    0x4(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <scanf@plt>
mov    (%rsp),%r11d
test   %r11d,%r11d
jle    11bd <main+0x9d>
lea    0x10(%rsp),%rbx
xor    %ebp,%ebp
lea    0xe99(%rip),%r14
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <scanf@plt>
add    $0x1,%rbp
movslq (%rsp),%r11
add    $0x4,%rbx
cmp    %r11,%rbp
jl     1170 <main+0x50>
mov    0x4(%rsp),%r10d
test   %r11d,%r11d
setg   %al
xor    %esi,%esi
cmp    %r11d,%r10d
jne    12ad <main+0x18d>
test   %r11d,%r11d
jle    12ad <main+0x18d>
mov    %r11d,%ecx
cmp    $0x8,%r11d
jae    11cb <main+0xab>
xor    %edx,%edx
xor    %esi,%esi
jmp    12a0 <main+0x180>
xor    %eax,%eax
mov    0x4(%rsp),%r10d
xor    %esi,%esi
jmp    12ad <main+0x18d>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    11f6 <main+0xd6>
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
jmp    124d <main+0x12d>
and    $0xfffffffffffffffc,%rsi
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
paddd  0x10(%rsp,%rdi,4),%xmm0
paddd  0x20(%rsp,%rdi,4),%xmm1
paddd  0x30(%rsp,%rdi,4),%xmm0
paddd  0x40(%rsp,%rdi,4),%xmm1
paddd  0x50(%rsp,%rdi,4),%xmm0
paddd  0x60(%rsp,%rdi,4),%xmm1
paddd  0x70(%rsp,%rdi,4),%xmm0
paddd  0x80(%rsp,%rdi,4),%xmm1
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1210 <main+0xf0>
test   %rbp,%rbp
je     1274 <main+0x154>
lea    (%rsp,%rdi,4),%rsi
add    $0x20,%rsi
shl    $0x5,%rbp
xor    %edi,%edi
paddd  -0x10(%rsi,%rdi,1),%xmm0
paddd  (%rsi,%rdi,1),%xmm1
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    1260 <main+0x140>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %rcx,%rdx
je     12ad <main+0x18d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0x10(%rsp,%rdx,4),%esi
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    12a0 <main+0x180>
cmp    %r11d,%r10d
jge    1782 <main+0x662>
test   %al,%al
je     1362 <main+0x242>
lea    -0x1(%r11),%r8d
xor    %r9d,%r9d
jmp    12e1 <main+0x1c1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9d
add    $0xffffffff,%r8d
cmp    %r11d,%r9d
je     1362 <main+0x242>
mov    %r9d,%edx
not    %edx
add    %r11d,%edx
test   %edx,%edx
jle    12d0 <main+0x1b0>
mov    0x10(%rsp),%ecx
cmp    $0x1,%edx
jne    1310 <main+0x1f0>
xor    %ebp,%ebp
test   $0x1,%dl
je     12d0 <main+0x1b0>
mov    0x14(%rsp,%rbp,4),%eax
cmp    %eax,%ecx
jle    12d0 <main+0x1b0>
mov    %eax,0x10(%rsp,%rbp,4)
mov    %ecx,0x14(%rsp,%rbp,4)
jmp    12d0 <main+0x1b0>
nop
mov    %r8d,%eax
and    $0xfffffffe,%eax
xor    %ebx,%ebx
jmp    1330 <main+0x210>
nopw   0x0(%rax,%rax,1)
mov    %edi,0x14(%rsp,%rbx,4)
mov    %ecx,0x18(%rsp,%rbx,4)
mov    %rbp,%rbx
cmp    %rbp,%rax
je     12f8 <main+0x1d8>
mov    0x14(%rsp,%rbx,4),%edi
cmp    %edi,%ecx
jle    1350 <main+0x230>
mov    %edi,0x10(%rsp,%rbx,4)
mov    %ecx,0x14(%rsp,%rbx,4)
jmp    1352 <main+0x232>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edi,%ecx
lea    0x2(%rbx),%rbp
mov    0x18(%rsp,%rbx,4),%edi
cmp    %edi,%ecx
jg     1320 <main+0x200>
mov    %edi,%ecx
jmp    1328 <main+0x208>
mov    %r11d,%eax
cltd
idiv   %r10d
test   %eax,%eax
jle    15dd <main+0x4bd>
mov    %edx,0x8(%rsp)
lea    -0x1(%r11),%r13d
mov    %eax,0xc(%rsp)
mov    %eax,%eax
xor    %edi,%edi
jmp    13a0 <main+0x280>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdi
sub    %r10d,%r13d
cmp    %rax,%rdi
je     15c9 <main+0x4a9>
mov    %r10d,%ebp
imul   %edi,%ebp
mov    %ebp,%ecx
not    %ecx
add    %r11d,%ecx
add    %r10d,%ebp
not    %ebp
add    %r11d,%ebp
cmp    %ebp,%ecx
jle    1390 <main+0x270>
movslq %r13d,%rcx
lea    -0x1(%rcx),%r8
add    $0x1,%rdi
movslq %ebp,%rdx
cmp    %rdx,%r8
mov    %rdx,%rbx
cmovl  %r8,%rbx
mov    %rcx,%r14
sub    %rbx,%r14
cmp    $0x8,%r14
jb     15a0 <main+0x480>
mov    %r14,%r15
and    $0xfffffffffffffff8,%r15
movd   %esi,%xmm1
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm8
lea    -0x8(%r15),%rsi
mov    %rsi,%r12
shr    $0x3,%r12
add    $0x1,%r12
pshufd $0xf5,%xmm8,%xmm9
test   %rsi,%rsi
je     15b7 <main+0x497>
lea    0x4(%rsp),%rsi
lea    (%rsi,%rcx,4),%rbp
cmp    %rdx,%r8
cmovge %rdx,%r8
mov    %rcx,%r9
sub    %r8,%r9
and    $0xfffffffffffffff8,%r9
add    $0xfffffffffffffff8,%r9
shr    $0x3,%r9
add    $0x1,%r9
and    $0xfffffffffffffffe,%r9
pxor   %xmm3,%xmm3
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x30(%rbp,%rsi,4),%xmm4
movdqu -0x20(%rbp,%rsi,4),%xmm5
movdqu -0x10(%rbp,%rsi,4),%xmm6
movdqu 0x0(%rbp,%rsi,4),%xmm7
pshufd $0x1b,%xmm7,%xmm0
pshufd $0x1b,%xmm6,%xmm2
pshufd $0x4e,%xmm7,%xmm7
pmuludq %xmm9,%xmm7
pshufd $0xe8,%xmm7,%xmm7
pmuludq %xmm8,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm7,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x4e,%xmm6,%xmm1
pmuludq %xmm9,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm8,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
paddd  %xmm3,%xmm2
pshufd $0x1b,%xmm5,%xmm1
pshufd $0x1b,%xmm4,%xmm3
pshufd $0x4e,%xmm5,%xmm5
pmuludq %xmm9,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pmuludq %xmm8,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm5,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x4e,%xmm4,%xmm0
pmuludq %xmm9,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm8,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm0,%xmm3
paddd  %xmm2,%xmm3
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%r9
jne    1450 <main+0x330>
neg    %rsi
test   $0x1,%r12b
je     1575 <main+0x455>
mov    %rcx,%rbp
sub    %rsi,%rbp
movdqu -0xc(%rsp,%rbp,4),%xmm0
movdqu 0x4(%rsp,%rbp,4),%xmm2
pshufd $0x1b,%xmm2,%xmm4
pshufd $0x1b,%xmm0,%xmm5
pshufd $0x4e,%xmm2,%xmm2
pmuludq %xmm9,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm8,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm2,%xmm4
paddd  %xmm4,%xmm1
pshufd $0x4e,%xmm0,%xmm0
pmuludq %xmm9,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm8,%xmm5
pshufd $0xe8,%xmm5,%xmm2
punpckldq %xmm0,%xmm2
paddd  %xmm2,%xmm3
paddd  %xmm3,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
cmp    %r15,%r14
je     1394 <main+0x274>
sub    %r15,%rcx
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp,%rcx,4),%ebp
imul   %edi,%ebp
add    %ebp,%esi
add    $0xffffffffffffffff,%rcx
cmp    %rdx,%rcx
jg     15a0 <main+0x480>
jmp    1394 <main+0x274>
pxor   %xmm3,%xmm3
xor    %esi,%esi
test   $0x1,%r12b
jne    1517 <main+0x3f7>
jmp    1575 <main+0x455>
mov    0xc(%rsp),%edi
add    $0x1,%edi
mov    0x8(%rsp),%edx
test   %edx,%edx
jg     15ea <main+0x4ca>
jmp    1782 <main+0x662>
mov    $0x1,%edi
test   %edx,%edx
jle    1782 <main+0x662>
mov    %edx,%ecx
cmp    $0x8,%edx
jae    15f8 <main+0x4d8>
xor    %edx,%edx
jmp    1770 <main+0x650>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %esi,%xmm0
mov    %edi,%eax
movd   %edi,%xmm1
pshufd $0x0,%xmm1,%xmm8
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
pshufd $0xf5,%xmm8,%xmm2
test   %rdi,%rdi
je     17a2 <main+0x682>
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
or     $0x2,%rbp
and    %rsi,%rbp
pxor   %xmm3,%xmm3
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa 0x10(%rsp,%rdi,4),%xmm5
movdqa 0x20(%rsp,%rdi,4),%xmm6
movdqa 0x30(%rsp,%rdi,4),%xmm7
movdqa 0x40(%rsp,%rdi,4),%xmm4
pshufd $0xf5,%xmm5,%xmm1
pmuludq %xmm8,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pmuludq %xmm2,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm5
paddd  %xmm0,%xmm5
pshufd $0xf5,%xmm6,%xmm0
pmuludq %xmm8,%xmm6
pshufd $0xe8,%xmm6,%xmm1
pmuludq %xmm2,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
paddd  %xmm3,%xmm1
pshufd $0xf5,%xmm7,%xmm3
pmuludq %xmm8,%xmm7
pshufd $0xe8,%xmm7,%xmm0
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm0
paddd  %xmm5,%xmm0
pshufd $0xf5,%xmm4,%xmm5
pmuludq %xmm8,%xmm4
pshufd $0xe8,%xmm4,%xmm3
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm4
punpckldq %xmm4,%xmm3
paddd  %xmm1,%xmm3
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1650 <main+0x530>
test   $0x1,%sil
je     1749 <main+0x629>
movdqa 0x10(%rsp,%rdi,4),%xmm1
movdqa 0x20(%rsp,%rdi,4),%xmm4
pshufd $0xf5,%xmm1,%xmm5
pmuludq %xmm8,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm1
paddd  %xmm1,%xmm0
pmuludq %xmm4,%xmm8
pshufd $0xe8,%xmm8,%xmm1
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm2
punpckldq %xmm2,%xmm1
paddd  %xmm1,%xmm3
paddd  %xmm3,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %rcx,%rdx
mov    %eax,%edi
je     1782 <main+0x662>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp,%rdx,4),%eax
imul   %edi,%eax
add    %eax,%esi
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1770 <main+0x650>
lea    0x87a(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm3,%xmm3
xor    %edi,%edi
test   $0x1,%sil
jne    16fc <main+0x5dc>
jmp    1749 <main+0x629>

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [4 x i8] c"%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 [100 x i32]
store i32 0, i32* %1
store i32 0, i32* %7
store i32 0, i32* %9
store i32 0, i32* %11
%13 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %10)
%14 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %5)
store i32 0, i32* %3
br label %15
15: ; preds = %24, %0
%16 = load i32, i32* %3
%17 = load i32, i32* %10
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %27
19: ; preds = %15
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %21
%23 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %22)
br label %24
24: ; preds = %19
%25 = load i32, i32* %3
%26 = add nsw i32 %25, 1
store i32 %26, i32* %3
br label %15
27: ; preds = %15
%28 = load i32, i32* %5
%29 = load i32, i32* %10
%30 = icmp eq i32 %28, %29
br i1 %30, label %31, label %47
31: ; preds = %27
store i32 0, i32* %3
br label %32
32: ; preds = %43, %31
%33 = load i32, i32* %3
%34 = load i32, i32* %10
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %46
36: ; preds = %32
%37 = load i32, i32* %3
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %38
%40 = load i32, i32* %39
%41 = load i32, i32* %9
%42 = add nsw i32 %41, %40
store i32 %42, i32* %9
br label %43
43: ; preds = %36
%44 = load i32, i32* %3
%45 = add nsw i32 %44, 1
store i32 %45, i32* %3
br label %32
46: ; preds = %32
br label %47
47: ; preds = %46, %27
%48 = load i32, i32* %5
%49 = load i32, i32* %10
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %166
51: ; preds = %47
store i32 0, i32* %3
br label %52
52: ; preds = %98, %51
%53 = load i32, i32* %3
%54 = load i32, i32* %10
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %101
56: ; preds = %52
store i32 0, i32* %4
br label %57
57: ; preds = %94, %56
%58 = load i32, i32* %4
%59 = load i32, i32* %10
%60 = load i32, i32* %3
%61 = sub nsw i32 %59, %60
%62 = sub nsw i32 %61, 1
%63 = icmp slt i32 %58, %62
br i1 %63, label %64, label %97
64: ; preds = %57
%65 = load i32, i32* %4
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %66
%68 = load i32, i32* %67
%69 = load i32, i32* %4
%70 = add nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %71
%73 = load i32, i32* %72
%74 = icmp sgt i32 %68, %73
br i1 %74, label %75, label %93
75: ; preds = %64
%76 = load i32, i32* %4
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %77
%79 = load i32, i32* %78
store i32 %79, i32* %8
%80 = load i32, i32* %4
%81 = add nsw i32 %80, 1
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %82
%84 = load i32, i32* %83
%85 = load i32, i32* %4
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %86
store i32 %84, i32* %87
%88 = load i32, i32* %8
%89 = load i32, i32* %4
%90 = add nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %91
store i32 %88, i32* %92
br label %93
93: ; preds = %75, %64
br label %94
94: ; preds = %93
%95 = load i32, i32* %4
%96 = add nsw i32 %95, 1
store i32 %96, i32* %4
br label %57
97: ; preds = %57
br label %98
98: ; preds = %97
%99 = load i32, i32* %3
%100 = add nsw i32 %99, 1
store i32 %100, i32* %3
br label %52
101: ; preds = %52
%102 = load i32, i32* %10
%103 = load i32, i32* %5
%104 = sdiv i32 %102, %103
store i32 %104, i32* %11
%105 = load i32, i32* %10
%106 = load i32, i32* %5
%107 = srem i32 %105, %106
store i32 %107, i32* %2
store i32 0, i32* %3
br label %108
108: ; preds = %144, %101
%109 = load i32, i32* %3
%110 = load i32, i32* %11
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %147
112: ; preds = %108
%113 = load i32, i32* %10
%114 = load i32, i32* %3
%115 = load i32, i32* %5
%116 = mul nsw i32 %114, %115
%117 = sub nsw i32 %113, %116
%118 = sub nsw i32 %117, 1
store i32 %118, i32* %4
br label %119
119: ; preds = %140, %112
%120 = load i32, i32* %4
%121 = load i32, i32* %10
%122 = load i32, i32* %5
%123 = sub nsw i32 %121, %122
%124 = load i32, i32* %3
%125 = load i32, i32* %5
%126 = mul nsw i32 %124, %125
%127 = sub nsw i32 %123, %126
%128 = sub nsw i32 %127, 1
%129 = icmp sgt i32 %120, %128
br i1 %129, label %130, label %143
130: ; preds = %119
%131 = load i32, i32* %3
%132 = add nsw i32 %131, 1
%133 = load i32, i32* %4
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %134
%136 = load i32, i32* %135
%137 = mul nsw i32 %132, %136
%138 = load i32, i32* %9
%139 = add nsw i32 %138, %137
store i32 %139, i32* %9
br label %140
140: ; preds = %130
%141 = load i32, i32* %4
%142 = add nsw i32 %141, -1
store i32 %142, i32* %4
br label %119
143: ; preds = %119
br label %144
144: ; preds = %143
%145 = load i32, i32* %3
%146 = add nsw i32 %145, 1
store i32 %146, i32* %3
br label %108
147: ; preds = %108
store i32 0, i32* %4
br label %148
148: ; preds = %162, %147
%149 = load i32, i32* %4
%150 = load i32, i32* %2
%151 = icmp slt i32 %149, %150
br i1 %151, label %152, label %165
152: ; preds = %148
%153 = load i32, i32* %3
%154 = add nsw i32 %153, 1
%155 = load i32, i32* %4
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [100 x i32], [100 x i32]* %12, i64 0, i64 %156
%158 = load i32, i32* %157
%159 = mul nsw i32 %154, %158
%160 = load i32, i32* %9
%161 = add nsw i32 %160, %159
store i32 %161, i32* %9
br label %162
162: ; preds = %152
%163 = load i32, i32* %4
%164 = add nsw i32 %163, 1
store i32 %164, i32* %4
br label %148
165: ; preds = %148
br label %166
166: ; preds = %165, %47
%167 = load i32, i32* %9
%168 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %167)
store i32 0, i32* %9
ret i32 0
}

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