#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 */
scalar_t__ ctoi(char);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
size_t strlen(char *);
void numbprocess(int *chainemc, int *mclength, char chaine[], int start,
                 int length) {
  int j, loop, dummy[50] = {0}, diviseur, nombre;
  char chainemod[50], chainemult[100], temp;
  strcpy(chainemod, "");
  chainemc[(*mclength)++] = 902;
  j = 0;
  while (j < length) {
    int longueur;
    int dumlength = 0;
    strcpy(chainemod, "");
    longueur = length - j;
    if (longueur > 44) {
      longueur = 44;
    }
    strcat(chainemod, "1");
    for (loop = 1; loop <= longueur; loop++) {
      chainemod[loop] = chaine[start + loop + j - 1];
    }
    chainemod[longueur + 1] = '\0';
    do {
      diviseur = 900;
      strcpy(chainemult, "");
      nombre = 0;
      while (strlen(chainemod) != 0) {
        nombre *= 10;
        nombre += ctoi(chainemod[0]);
        for (loop = 0; loop < (int)strlen(chainemod); loop++) {
          chainemod[loop] = chainemod[loop + 1];
        }
        if (nombre < diviseur) {
          if (strlen(chainemult) != 0) {
            strcat(chainemult, "0");
          }
        } else {
          temp = (nombre / diviseur) + '0';
          chainemult[strlen(chainemult) + 1] = '\0';
          chainemult[strlen(chainemult)] = temp;
        }
        nombre = nombre % diviseur;
      }
      diviseur = nombre;
      for (loop = dumlength; loop > 0; loop--) {
        dummy[loop] = dummy[loop - 1];
      }
      dummy[0] = diviseur;
      dumlength++;
      strcpy(chainemod, chainemult);
    } while (strlen(chainemult) != 0);
    for (loop = 0; loop < dumlength; loop++) {
      chainemc[(*mclength)++] = dummy[loop];
    }
    j += longueur;
  }
}


x86 assembly (clang, -O0):
<numbprocess>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0xc8,%edx
call   1060 <memset@plt>
lea    -0x130(%rbp),%rdi
lea    0xe74(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rdx
mov    (%rdx),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,(%rdx)
movslq %ecx,%rcx
movl   $0x386,(%rax,%rcx,4)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    14b4 <numbprocess+0x364>
movl   $0x0,-0x1ac(%rbp)
lea    -0x130(%rbp),%rdi
lea    0xe29(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x20(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x1a8(%rbp)
cmpl   $0x2c,-0x1a8(%rbp)
jle    1202 <numbprocess+0xb2>
movl   $0x2c,-0x1a8(%rbp)
lea    -0x130(%rbp),%rdi
lea    0xdf0(%rip),%rsi
call   1070 <strcat@plt>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1a8(%rbp),%eax
jg     125a <numbprocess+0x10a>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    121c <numbprocess+0xcc>
mov    -0x1a8(%rbp),%eax
add    $0x1,%eax
cltq
movb   $0x0,-0x130(%rbp,%rax,1)
movl   $0x384,-0xf4(%rbp)
lea    -0x1a0(%rbp),%rdi
lea    0xd7e(%rip),%rsi
call   1030 <strcpy@plt>
movl   $0x0,-0xf8(%rbp)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%rax
je     13d2 <numbprocess+0x282>
imul   $0xa,-0xf8(%rbp),%eax
mov    %eax,-0xf8(%rbp)
movsbl -0x130(%rbp),%edi
call   1040 <ctoi@plt>
mov    %rax,%rcx
movslq -0xf8(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0xf8(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1b0(%rbp)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x1b0(%rbp),%eax
cmp    %ecx,%eax
jge    132b <numbprocess+0x1db>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x130(%rbp,%rax,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12dd <numbprocess+0x18d>
mov    -0xf8(%rbp),%eax
cmp    -0xf4(%rbp),%eax
jge    136b <numbprocess+0x21b>
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%rax
je     1366 <numbprocess+0x216>
lea    -0x1a0(%rbp),%rdi
lea    0xca1(%rip),%rsi
call   1070 <strcat@plt>
jmp    13ba <numbprocess+0x26a>
mov    -0xf8(%rbp),%eax
cltd
idivl  -0xf4(%rbp)
add    $0x30,%eax
mov    %al,-0x1a1(%rbp)
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
movb   $0x0,-0x19f(%rbp,%rax,1)
mov    -0x1a1(%rbp),%al
mov    %al,-0x1b1(%rbp)
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
mov    -0x1b1(%rbp),%cl
mov    %cl,-0x1a0(%rbp,%rax,1)
mov    -0xf8(%rbp),%eax
cltd
idivl  -0xf4(%rbp)
mov    %edx,-0xf8(%rbp)
jmp    1294 <numbprocess+0x144>
mov    -0xf8(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0x1ac(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1419 <numbprocess+0x2c9>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xf0(%rbp,%rax,4),%ecx
movslq -0x28(%rbp),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    13e7 <numbprocess+0x297>
mov    -0xf4(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0x1ac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1ac(%rbp)
lea    -0x130(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%rax
jne    126d <numbprocess+0x11d>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1ac(%rbp),%eax
jge    14a3 <numbprocess+0x353>
movslq -0x28(%rbp),%rax
mov    -0xf0(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rsi
mov    (%rsi),%ecx
mov    %ecx,%edi
add    $0x1,%edi
mov    %edi,(%rsi)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1464 <numbprocess+0x314>
mov    -0x1a8(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    11b6 <numbprocess+0x66>
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<numbprocess>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
mov    %r8d,%r12d
mov    %rcx,0x8(%rsp)
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%rbp
xorps  %xmm0,%xmm0
movaps %xmm0,0x160(%rsp)
movaps %xmm0,0x150(%rsp)
movaps %xmm0,0x140(%rsp)
movaps %xmm0,0x130(%rsp)
movaps %xmm0,0x120(%rsp)
movaps %xmm0,0x110(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movq   $0x0,0x170(%rsp)
lea    0xe2b(%rip),%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
movslq (%rbx),%rax
lea    0x1(%rax),%ecx
mov    %ecx,(%rbx)
movl   $0x386,0x0(%rbp,%rax,4)
test   %r12d,%r12d
jle    1921 <numbprocess+0x7e1>
mov    %rbp,%r8
mov    0x8(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x78(%rsp)
xor    %ebp,%ebp
lea    0x40(%rsp),%r14
lea    0x180(%rsp),%r15
mov    %r12d,0x14(%rsp)
mov    %r13,0x90(%rsp)
mov    %rbx,0x88(%rsp)
mov    %r8,0x80(%rsp)
jmp    1255 <numbprocess+0x115>
nopl   0x0(%rax)
mov    0x18(%rsp),%rbp
add    0x98(%rsp),%ebp
cmp    %r12d,%ebp
jge    1921 <numbprocess+0x7e1>
mov    %r14,%rdi
lea    0xda4(%rip),%rsi
call   1030 <strcpy@plt>
sub    %ebp,%r12d
cmp    $0x2c,%r12d
mov    $0x2c,%ebx
cmovl  %r12d,%ebx
mov    %r14,%rdi
lea    0xd82(%rip),%rsi
call   1060 <strcat@plt>
mov    %rbx,%rdi
test   %edi,%edi
mov    %rbp,0x18(%rsp)
mov    %rbx,0x98(%rsp)
jle    1370 <numbprocess+0x230>
mov    0x78(%rsp),%rax
lea    (%rax,%rbp,1),%ecx
lea    0x1(%rdi),%r8d
mov    %edi,%r11d
lea    0x1(%r11),%rdx
mov    $0x1,%esi
cmp    $0x8,%edi
jae    17e0 <numbprocess+0x6a0>
mov    %edx,%edi
sub    %esi,%edi
mov    %rsi,%rax
not    %rax
add    %rdx,%rax
and    $0x3,%rdi
je     12f9 <numbprocess+0x1b9>
neg    %rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rcx,%rsi,1),%ebp
movslq %ebp,%rbp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,0x40(%rsp,%rsi,1)
add    $0x1,%rsi
inc    %rdi
jne    12e0 <numbprocess+0x1a0>
cmp    $0x3,%rax
jb     1374 <numbprocess+0x234>
mov    0x8(%rsp),%rax
mov    0x18(%rsp),%rdi
add    %edi,%eax
lea    0x43(%rsp),%rdi
lea    (%rsi,%rcx,1),%ebp
movslq %ebp,%rbp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,-0x3(%rdi,%rsi,1)
lea    (%rsi,%rax,1),%rbp
movslq %ebp,%rbp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,-0x2(%rdi,%rsi,1)
lea    0x1(%rbp),%ebx
movslq %ebx,%rbx
movzbl 0x0(%r13,%rbx,1),%ebx
mov    %bl,-0x1(%rdi,%rsi,1)
add    $0x2,%ebp
movslq %ebp,%rbp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,(%rdi,%rsi,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rdi
add    $0x4,%rax
add    $0x4,%rcx
cmp    %rdx,%rsi
jne    1310 <numbprocess+0x1d0>
jmp    1374 <numbprocess+0x234>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rdi),%r8d
movslq %r8d,%rax
movb   $0x0,0x40(%rsp,%rax,1)
mov    $0xffffffff,%eax
lea    -0x8(%rax),%rcx
movq   $0xfffffffffffffff9,0x20(%rsp)
ff ff
mov    $0x1,%eax
mov    $0xffffffff,%edx
lea    0xa4(%rsp),%r13
xor    %r12d,%r12d
jmp    13f7 <numbprocess+0x2b7>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebp,0xb0(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
call   1030 <strcpy@plt>
add    $0x4,%r13
mov    0x38(%rsp),%rcx
add    $0x1,%rcx
mov    0x30(%rsp),%rdx
add    $0x1,%rdx
addq   $0x1,0x20(%rsp)
mov    0xa8(%rsp),%rsi
lea    0x1(%rsi),%eax
cmpb   $0x0,0x180(%rsp)
je     1720 <numbprocess+0x5e0>
mov    %rdx,0x30(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rax,0xa8(%rsp)
test   %r12,%r12
mov    $0x1,%eax
mov    %r12,0x28(%rsp)
cmovle %r12,%rax
mov    %rax,0xa0(%rsp)
mov    %r15,%rdi
lea    0xbd7(%rip),%rsi
call   1030 <strcpy@plt>
mov    0x40(%rsp),%al
xor    %ebp,%ebp
jmp    1495 <numbprocess+0x355>
nopl   0x0(%rax)
mov    %ebp,%ebx
mov    $0x91a2b3c5,%eax
imul   %rax,%rbx
shr    $0x29,%rbx
add    $0x30,%bl
mov    %r15,%rdi
call   1050 <strlen@plt>
movb   $0x0,0x1(%rax,%r15,1)
mov    %r15,%rdi
call   1050 <strlen@plt>
mov    %bl,0x180(%rsp,%rax,1)
movslq %ebp,%rax
imul   $0xffffffff91a2b3c5,%rax,%rax
shr    $0x20,%rax
add    %ebp,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
sar    $0x9,%eax
add    %ecx,%eax
imul   $0x384,%eax,%eax
sub    %eax,%ebp
mov    0x40(%rsp),%al
test   %al,%al
je     1520 <numbprocess+0x3e0>
movsbl %al,%edi
call   1040 <ctoi@plt>
mov    %rax,%r12
mov    %r14,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    14e0 <numbprocess+0x3a0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%rax),%rbx
movzbl 0x41(%rsp,%rax,1),%ecx
mov    %cl,0x40(%rsp,%rax,1)
mov    %r14,%rdi
call   1050 <strlen@plt>
movslq %eax,%rcx
mov    %rbx,%rax
cmp    %rcx,%rbx
jl     14c0 <numbprocess+0x380>
lea    0x0(%rbp,%rbp,4),%eax
lea    (%r12,%rax,2),%ebp
cmp    $0x383,%ebp
jg     1440 <numbprocess+0x300>
cmpb   $0x0,0x180(%rsp)
je     146f <numbprocess+0x32f>
mov    %r15,%rdi
lea    0xaf6(%rip),%rsi
call   1060 <strcat@plt>
jmp    146f <numbprocess+0x32f>
cs nopw 0x0(%rax,%rax,1)
mov    0x28(%rsp),%rbx
lea    0x1(%rbx),%r12
test   %ebx,%ebx
je     13b0 <numbprocess+0x270>
mov    %r12,%r10
mov    0xa0(%rsp),%rsi
sub    %rsi,%r10
mov    %rbx,%rdx
cmp    $0x8,%r10
jae    1570 <numbprocess+0x430>
add    $0x1,%rdx
nopl   0x0(%rax)
lea    -0x2(%rdx),%eax
mov    0xb0(%rsp,%rax,4),%eax
mov    %eax,0xac(%rsp,%rdx,4)
add    $0xffffffffffffffff,%rdx
cmp    $0x1,%rdx
jg     1550 <numbprocess+0x410>
jmp    13b0 <numbprocess+0x270>
lea    -0x1(%rbx),%r9d
mov    %rbx,%rcx
sub    %rsi,%rcx
mov    %rcx,%rax
mov    $0x4,%edx
mul    %rdx
seto   %r8b
mov    %rbx,%rdx
cmp    %ecx,%r9d
jb     1548 <numbprocess+0x408>
shr    $0x20,%rcx
mov    %rbx,%rdx
jne    1548 <numbprocess+0x408>
lea    (%rsp,%rbx,4),%rdi
add    $0xb0,%rdi
mov    %rdi,%rcx
sub    %rax,%rcx
mov    %rbx,%rdx
cmp    %rdi,%rcx
ja     1548 <numbprocess+0x408>
mov    %rbx,%rdx
test   %r8b,%r8b
jne    1548 <numbprocess+0x408>
lea    (%rsp,%r9,4),%rcx
add    $0xb0,%rcx
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rbx,%rdx
cmp    %rcx,%rdi
ja     1548 <numbprocess+0x408>
mov    %rbx,%rdx
test   %r8b,%r8b
jne    1548 <numbprocess+0x408>
mov    $0xffffffff,%eax
add    %ebx,%eax
lea    (%rsp,%rsi,4),%rcx
add    $0xb0,%rcx
lea    0xb4(%rsp),%rdx
lea    (%rdx,%rax,4),%rdx
cmp    %rdx,%rcx
jae    163a <numbprocess+0x4fa>
lea    0x0(,%rbx,4),%rcx
neg    %rcx
add    %rsi,%rax
lea    (%rsp,%rbx,4),%rdi
add    $0xb4,%rdi
add    %rsp,%rcx
add    $0xb0,%rcx
lea    (%rcx,%rax,4),%rax
mov    %rbx,%rdx
cmp    %rdi,%rax
jb     1548 <numbprocess+0x408>
lea    -0x8(%r10),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
cmp    $0x8,%rcx
jae    1653 <numbprocess+0x513>
xor    %ecx,%ecx
jmp    16cb <numbprocess+0x58b>
mov    0x20(%rsp),%rdx
sub    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
mov    0x38(%rsp),%rax
mov    0x30(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%rcx,1),%edi
movups 0x94(%rsp,%rdi,4),%xmm0
movups 0xa4(%rsp,%rdi,4),%xmm1
movups %xmm1,0x0(%r13,%rcx,4)
movups %xmm0,-0x10(%r13,%rcx,4)
lea    (%rax,%rcx,1),%edi
movups 0x94(%rsp,%rdi,4),%xmm0
movups 0xa4(%rsp,%rdi,4),%xmm1
movups %xmm1,-0x20(%r13,%rcx,4)
movups %xmm0,-0x30(%r13,%rcx,4)
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1680 <numbprocess+0x540>
neg    %rcx
mov    %r10,%rdi
and    $0xfffffffffffffff8,%rdi
test   $0x1,%r8b
je     1705 <numbprocess+0x5c5>
mov    %rbx,%rax
sub    %rcx,%rax
mov    $0xffffffff,%ecx
add    %eax,%ecx
movups 0x94(%rsp,%rcx,4),%xmm0
movups 0xa4(%rsp,%rcx,4),%xmm1
movups %xmm1,0xa4(%rsp,%rax,4)
movups %xmm0,0x94(%rsp,%rax,4)
cmp    %rdi,%r10
je     13b0 <numbprocess+0x270>
mov    %rbx,%rdx
sub    %rdi,%rdx
jmp    1548 <numbprocess+0x408>
nopl   0x0(%rax)
mov    0x28(%rsp),%rdx
add    $0x1,%edx
mov    0x88(%rsp),%rbx
movslq (%rbx),%rax
lea    0x1(%rax),%ecx
mov    %ecx,(%rbx)
mov    0x80(%rsp),%r8
mov    %ebp,(%r8,%rax,4)
cmp    $0x1,%edx
mov    0x14(%rsp),%r12d
mov    0x90(%rsp),%r13
je     1240 <numbprocess+0x100>
lea    -0x1(%rdx),%rax
mov    $0x1,%ecx
cmp    $0x2,%rdx
je     17b8 <numbprocess+0x678>
mov    %esi,%edx
add    $0xffffffffffffffff,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp,%rcx,4),%esi
movslq (%rbx),%rdi
lea    0x1(%rdi),%ebp
mov    %ebp,(%rbx)
mov    %esi,(%r8,%rdi,4)
mov    0xb4(%rsp,%rcx,4),%esi
movslq (%rbx),%rdi
lea    0x1(%rdi),%ebp
mov    %ebp,(%rbx)
mov    %esi,(%r8,%rdi,4)
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    1780 <numbprocess+0x640>
test   $0x1,%al
je     1240 <numbprocess+0x100>
mov    0xb0(%rsp,%rcx,4),%eax
movslq (%rbx),%rcx
lea    0x1(%rcx),%edx
mov    %edx,(%rbx)
mov    %eax,(%r8,%rcx,4)
jmp    1240 <numbprocess+0x100>
nopl   0x0(%rax,%rax,1)
lea    -0x2(%rdx),%rax
mov    0x8(%rsp),%rdi
lea    (%rdi,%rbp,1),%r10d
lea    (%rax,%r10,1),%edi
cmp    %r10d,%edi
jl     12bc <numbprocess+0x17c>
shr    $0x20,%rax
jne    12bc <numbprocess+0x17c>
cmp    $0x20,%r11d
jae    1811 <numbprocess+0x6d1>
xor    %edi,%edi
jmp    18bb <numbprocess+0x77b>
mov    %r11d,%edi
and    $0xffffffe0,%edi
lea    -0x20(%rdi),%rax
mov    %rax,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rax,%rax
je     1907 <numbprocess+0x7c7>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
mov    %r10d,%eax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
cltq
movups 0x0(%r13,%rax,1),%xmm0
movups 0x10(%r13,%rax,1),%xmm1
movups %xmm0,0x41(%rsp,%rsi,1)
movups %xmm1,0x51(%rsp,%rsi,1)
lea    0x20(%rax),%ebx
movslq %ebx,%rbx
movups 0x0(%r13,%rbx,1),%xmm0
movups 0x10(%r13,%rbx,1),%xmm1
movups %xmm0,0x61(%rsp,%rsi,1)
movups %xmm1,0x71(%rsp,%rsi,1)
add    $0x40,%rsi
add    $0x40,%eax
add    $0xfffffffffffffffe,%rbp
jne    1840 <numbprocess+0x700>
test   $0x1,%r9b
je     18ac <numbprocess+0x76c>
mov    %rsi,%rax
or     $0x1,%rax
or     $0x1,%esi
add    %ecx,%esi
movslq %esi,%rsi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x40(%rsp,%rax,1)
movups %xmm1,0x50(%rsp,%rax,1)
cmp    %rdi,%r11
je     1374 <numbprocess+0x234>
test   $0x18,%r11b
je     1915 <numbprocess+0x7d5>
cmp    $0x2c,%r12d
mov    $0x2c,%eax
cmovge %eax,%r12d
add    $0x1,%r12d
add    $0xffffffffffffffff,%r12
mov    %r12,%rax
and    $0xfffffffffffffff8,%rax
lea    0x1(%rax),%rsi
mov    %r10d,%ebp
xchg   %ax,%ax
lea    (%rdi,%rbp,1),%ebx
movslq %ebx,%rbx
mov    0x0(%r13,%rbx,1),%rbx
mov    %rbx,0x41(%rsp,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rax
jne    18e0 <numbprocess+0x7a0>
cmp    %rax,%r12
jne    12bc <numbprocess+0x17c>
jmp    1374 <numbprocess+0x234>
xor    %esi,%esi
test   $0x1,%r9b
jne    1887 <numbprocess+0x747>
jmp    18ac <numbprocess+0x76c>
or     $0x1,%rdi
mov    %rdi,%rsi
jmp    12bc <numbprocess+0x17c>
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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