#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 */
bool SolutionSameDigitsAsNumber(int *Number, int NumberOfDigits,
                                int *Solution) {
  int counter = 0;
  bool Valid = false;
  while (counter <= NumberOfDigits - 1 - counter) {
    if (counter == NumberOfDigits - 1 - counter) {
      if (Number[counter] % 2 == 0) {
        Solution[counter] = Number[counter] / 2;
        Valid = true;
        break;
      } else {
        Valid = false;
        break;
      }
    }
    if (Number[counter] == Number[NumberOfDigits - 1 - counter]) {
      if (Number[counter] == 0)
        Solution[counter] = Solution[NumberOfDigits - 1 - counter] = 0;
      else {
        Solution[counter] = 1;
        Solution[NumberOfDigits - 1 - counter] = Number[counter] - 1;
      }
      Valid = true;
    } else if (Number[counter] - 1 == Number[NumberOfDigits - 1 - counter]) {
      Number[counter + 1] += 10;
      if (Number[counter] - 1 == 0)
        Solution[counter] = Solution[NumberOfDigits - 1 - counter] = 0;
      else {
        Solution[counter] = 1;
        Solution[NumberOfDigits - 1 - counter] = Number[counter] - 2;
      }
      Valid = true;
    } else if (Number[counter] - 10 == Number[NumberOfDigits - 1 - counter]) {
      if (Number[NumberOfDigits - 2 - counter] == 0) {
        Number[NumberOfDigits - 2 - counter] = 9;
        int inner_counter = 1;
        while (Number[NumberOfDigits - 2 - counter - inner_counter] == 0) {
          Number[NumberOfDigits - 2 - counter - inner_counter] = 9;
          inner_counter++;
        }
        if (NumberOfDigits - 2 - counter - inner_counter == counter)
          ;
        else {
          Number[NumberOfDigits - 2 - counter - inner_counter] -= 1;
        }
      } else {
        if (NumberOfDigits - 2 - counter == counter)
          ;
        else
          Number[NumberOfDigits - 2 - counter] -= 1;
      }
      if (Number[counter] == 10)
        Solution[counter] = Solution[NumberOfDigits - 1 - counter] = 5;
      else {
        Solution[counter] = 9;
        Solution[NumberOfDigits - 1 - counter] = Number[counter] - 9;
      }
      Valid = true;
    } else if (Number[counter] - 11 == Number[NumberOfDigits - 1 - counter]) {
      Number[counter + 1] += 10;
      if (Number[NumberOfDigits - 2 - counter] == 0) {
        Number[NumberOfDigits - 2 - counter] = 9;
        int inner_counter = 1;
        while (Number[NumberOfDigits - 2 - counter - inner_counter] == 0) {
          Number[NumberOfDigits - 2 - counter - inner_counter] = 9;
          inner_counter++;
        }
        if (NumberOfDigits - 2 - counter == counter)
          ;
        else
          Number[NumberOfDigits - 2 - counter - inner_counter] -= 1;
      } else {
        if (NumberOfDigits - 2 - counter == counter)
          ;
        else
          Number[NumberOfDigits - 2 - counter] -= 1;
      }
      if (Number[counter] == 10)
        Solution[counter] = Solution[NumberOfDigits - 1 - counter] = 5;
      else {
        Solution[counter] = 9;
        Solution[NumberOfDigits - 1 - counter] = Number[counter] - 10;
        Valid = true;
      }
    } else {
      Valid = false;
      break;
    }
    counter++;
  }
  return Valid;
}


x86 assembly (clang, -O0):
<SolutionSameDigitsAsNumber>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jg     1647 <SolutionSameDigitsAsNumber+0x547>
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jne    1199 <SolutionSameDigitsAsNumber+0x99>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    118d <SolutionSameDigitsAsNumber+0x8d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
jmp    1647 <SolutionSameDigitsAsNumber+0x547>
movl   $0x0,-0x20(%rbp)
jmp    1647 <SolutionSameDigitsAsNumber+0x547>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1236 <SolutionSameDigitsAsNumber+0x136>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    11fa <SolutionSameDigitsAsNumber+0xfa>
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    122a <SolutionSameDigitsAsNumber+0x12a>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x1,%edx
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
jmp    1639 <SolutionSameDigitsAsNumber+0x539>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    12f1 <SolutionSameDigitsAsNumber+0x1f1>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0xa,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jne    12b5 <SolutionSameDigitsAsNumber+0x1b5>
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    12e5 <SolutionSameDigitsAsNumber+0x1e5>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x2,%edx
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
jmp    1634 <SolutionSameDigitsAsNumber+0x534>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0xa,%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    147e <SolutionSameDigitsAsNumber+0x37e>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    13d0 <SolutionSameDigitsAsNumber+0x2d0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x9,(%rax,%rcx,4)
movl   $0x1,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1395 <SolutionSameDigitsAsNumber+0x295>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x9,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1350 <SolutionSameDigitsAsNumber+0x250>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
sub    -0x1c(%rbp),%eax
sub    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    13af <SolutionSameDigitsAsNumber+0x2af>
jmp    13cb <SolutionSameDigitsAsNumber+0x2cb>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1405 <SolutionSameDigitsAsNumber+0x305>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
sub    -0x1c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    13e7 <SolutionSameDigitsAsNumber+0x2e7>
jmp    1400 <SolutionSameDigitsAsNumber+0x300>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1405 <SolutionSameDigitsAsNumber+0x305>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0xa,(%rax,%rcx,4)
jne    1442 <SolutionSameDigitsAsNumber+0x342>
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x5,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x5,(%rax,%rcx,4)
jmp    1472 <SolutionSameDigitsAsNumber+0x372>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x9,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x9,%edx
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
jmp    162f <SolutionSameDigitsAsNumber+0x52f>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0xb,%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    161e <SolutionSameDigitsAsNumber+0x51e>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0xa,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1570 <SolutionSameDigitsAsNumber+0x470>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x9,(%rax,%rcx,4)
movl   $0x1,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1538 <SolutionSameDigitsAsNumber+0x438>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x9,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14f3 <SolutionSameDigitsAsNumber+0x3f3>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
sub    -0x1c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    154f <SolutionSameDigitsAsNumber+0x44f>
jmp    156b <SolutionSameDigitsAsNumber+0x46b>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    15a5 <SolutionSameDigitsAsNumber+0x4a5>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
sub    -0x1c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1587 <SolutionSameDigitsAsNumber+0x487>
jmp    15a0 <SolutionSameDigitsAsNumber+0x4a0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    15a5 <SolutionSameDigitsAsNumber+0x4a5>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0xa,(%rax,%rcx,4)
jne    15e2 <SolutionSameDigitsAsNumber+0x4e2>
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x5,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x5,(%rax,%rcx,4)
jmp    1619 <SolutionSameDigitsAsNumber+0x519>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x9,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    $0xa,%edx
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
jmp    162a <SolutionSameDigitsAsNumber+0x52a>
movl   $0x0,-0x20(%rbp)
jmp    1647 <SolutionSameDigitsAsNumber+0x547>
jmp    162f <SolutionSameDigitsAsNumber+0x52f>
jmp    1634 <SolutionSameDigitsAsNumber+0x534>
jmp    1639 <SolutionSameDigitsAsNumber+0x539>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111d <SolutionSameDigitsAsNumber+0x1d>
mov    -0x20(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<SolutionSameDigitsAsNumber>:
push   %rbp
push   %r15
push   %r14
push   %rbx
mov    %esi,%eax
add    $0xffffffff,%eax
js     12fd <SolutionSameDigitsAsNumber+0x1fd>
movslq %esi,%r10
lea    -0x2(%r10),%r8
mov    %eax,%esi
lea    (%rdi,%r10,4),%r9
add    $0xfffffffffffffff4,%r9
add    $0xfffffffffffffffd,%r10
xor    %r14d,%r14d
xor    %r11d,%r11d
xor    %eax,%eax
jmp    1171 <SolutionSameDigitsAsNumber+0x71>
test   %ecx,%ecx
je     1199 <SolutionSameDigitsAsNumber+0x99>
movl   $0x1,(%rdx,%r14,4)
mov    (%rdi,%r14,4),%ebx
add    $0xffffffff,%ebx
mov    $0x1,%eax
mov    %rsi,%rcx
mov    %ebx,(%rdx,%rcx,4)
lea    0x1(%r14),%rcx
add    $0xffffffffffffffff,%r11
add    $0xffffffffffffffff,%rsi
movslq %esi,%rbx
add    $0xfffffffffffffffc,%r9
add    $0xffffffffffffffff,%r10
cmp    %rbx,%r14
mov    %rcx,%r14
jge    1320 <SolutionSameDigitsAsNumber+0x220>
cmp    %rsi,%r14
je     1301 <SolutionSameDigitsAsNumber+0x201>
mov    (%rdi,%r14,4),%ecx
mov    (%rdi,%rsi,4),%ebx
cmp    %ebx,%ecx
je     1130 <SolutionSameDigitsAsNumber+0x30>
lea    -0x1(%rcx),%ebp
cmp    %ebx,%ebp
jne    11b0 <SolutionSameDigitsAsNumber+0xb0>
lea    0x1(%r14),%eax
addl   $0xa,(%rdi,%rax,4)
cmp    $0x1,%ecx
jne    11d6 <SolutionSameDigitsAsNumber+0xd6>
movl   $0x0,(%rdx,%rsi,4)
mov    $0x1,%eax
xor    %ebx,%ebx
jmp    12e1 <SolutionSameDigitsAsNumber+0x1e1>
nopl   0x0(%rax)
lea    -0xa(%rcx),%ebp
cmp    %ebx,%ebp
jne    11ea <SolutionSameDigitsAsNumber+0xea>
lea    (%r11,%r8,1),%rbx
mov    (%rdi,%rbx,4),%eax
test   %eax,%eax
je     121e <SolutionSameDigitsAsNumber+0x11e>
mov    %ebx,%ecx
cmp    %r14,%rcx
je     1281 <SolutionSameDigitsAsNumber+0x181>
lea    (%rdi,%rbx,4),%rcx
jmp    127c <SolutionSameDigitsAsNumber+0x17c>
movl   $0x1,(%rdx,%r14,4)
mov    (%rdi,%r14,4),%ebx
add    $0xfffffffe,%ebx
jmp    1143 <SolutionSameDigitsAsNumber+0x43>
add    $0xfffffff5,%ecx
cmp    %ebx,%ecx
jne    12fd <SolutionSameDigitsAsNumber+0x1fd>
lea    0x1(%r14),%ecx
addl   $0xa,(%rdi,%rcx,4)
lea    (%r11,%r8,1),%r15
mov    (%rdi,%r15,4),%ebx
test   %ebx,%ebx
je     123b <SolutionSameDigitsAsNumber+0x13b>
mov    %r15d,%ecx
cmp    %r14,%rcx
je     12ce <SolutionSameDigitsAsNumber+0x1ce>
lea    (%rdi,%r15,4),%rcx
jmp    12c9 <SolutionSameDigitsAsNumber+0x1c9>
movl   $0x9,(%rdi,%rbx,4)
mov    -0x4(%rdi,%rbx,4),%eax
test   %eax,%eax
je     1256 <SolutionSameDigitsAsNumber+0x156>
lea    (%rdi,%rbx,4),%rcx
add    $0xfffffffffffffffc,%rcx
add    $0xffffffffffffffff,%rbx
jmp    1275 <SolutionSameDigitsAsNumber+0x175>
movl   $0x9,(%rdi,%r15,4)
mov    -0x4(%rdi,%r15,4),%ebx
test   %ebx,%ebx
je     12aa <SolutionSameDigitsAsNumber+0x1aa>
lea    (%rdi,%r15,4),%rcx
add    $0xfffffffffffffffc,%rcx
jmp    12c1 <SolutionSameDigitsAsNumber+0x1c1>
mov    %r9,%rcx
mov    %r10,%rbx
nopl   0x0(%rax)
movl   $0x9,(%rcx)
mov    -0x4(%rcx),%eax
add    $0xfffffffffffffffc,%rcx
add    $0xffffffffffffffff,%rbx
test   %eax,%eax
je     1260 <SolutionSameDigitsAsNumber+0x160>
mov    %ebx,%ebx
cmp    %r14,%rbx
je     1281 <SolutionSameDigitsAsNumber+0x181>
add    $0xffffffff,%eax
mov    %eax,(%rcx)
cmpl   $0xa,(%rdi,%r14,4)
jne    1296 <SolutionSameDigitsAsNumber+0x196>
movl   $0x5,(%rdx,%rsi,4)
mov    $0x1,%eax
jmp    12dc <SolutionSameDigitsAsNumber+0x1dc>
movl   $0x9,(%rdx,%r14,4)
mov    (%rdi,%r14,4),%ebx
add    $0xfffffff7,%ebx
jmp    1143 <SolutionSameDigitsAsNumber+0x43>
mov    %r9,%rcx
nopl   (%rax)
movl   $0x9,(%rcx)
mov    -0x4(%rcx),%ebx
add    $0xfffffffffffffffc,%rcx
test   %ebx,%ebx
je     12b0 <SolutionSameDigitsAsNumber+0x1b0>
mov    %r15d,%ebp
cmp    %r14,%rbp
je     12ce <SolutionSameDigitsAsNumber+0x1ce>
add    $0xffffffff,%ebx
mov    %ebx,(%rcx)
cmpl   $0xa,(%rdi,%r14,4)
jne    12e9 <SolutionSameDigitsAsNumber+0x1e9>
movl   $0x5,(%rdx,%rsi,4)
mov    $0x5,%ebx
mov    %r14,%rcx
jmp    114b <SolutionSameDigitsAsNumber+0x4b>
movl   $0x9,(%rdx,%r14,4)
mov    (%rdi,%r14,4),%ebx
add    $0xfffffff6,%ebx
jmp    1143 <SolutionSameDigitsAsNumber+0x43>
xor    %eax,%eax
jmp    1320 <SolutionSameDigitsAsNumber+0x220>
mov    %r14d,%ecx
mov    (%rdi,%rcx,4),%esi
xor    %eax,%eax
test   $0x1,%sil
jne    1320 <SolutionSameDigitsAsNumber+0x220>
mov    %esi,%eax
shr    $0x1f,%eax
add    %esi,%eax
sar    %eax
mov    %eax,(%rdx,%rcx,4)
mov    $0x1,%eax
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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