#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 */
typedef int /*<<< orphan*/ mpz_t;

/* Variables and functions */
int GetWeight(char *);
int /*<<< orphan*/ free(int /*<<< orphan*/ *);
int /*<<< orphan*/ mpz_add(int /*<<< orphan*/, int /*<<< orphan*/,
                           int /*<<< orphan*/);
int /*<<< orphan*/ mpz_clear(int /*<<< orphan*/);
int /*<<< orphan*/ mpz_init(int /*<<< orphan*/);
int /*<<< orphan*/ mpz_init_set_ui(int /*<<< orphan*/, int);
int /*<<< orphan*/ mpz_mul_2exp(int /*<<< orphan*/, int /*<<< orphan*/, int);
int /*<<< orphan*/ mpz_out_str(int /*<<< orphan*/, int, int /*<<< orphan*/);
int /*<<< orphan*/ mpz_set(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ mpz_set_ui(int /*<<< orphan*/, int);
int /*<<< orphan*/ mpz_sub(int /*<<< orphan*/, int /*<<< orphan*/,
                           int /*<<< orphan*/);
int /*<<< orphan*/ *my_malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ stdout;
int strlen(char *);
DoSingleNumberSAS(char *str, int number, int *done, int *negated, mpz_t *result,
                  int indice) {
  char neg;
  int last, j, weight, localcurrent, length, cost;
  char isfirst;
  mpz_t un, tempmpz, *res;
  mpz_init_set_ui(un, 1);
  mpz_init(tempmpz);
  last = 0;
  cost = 0;
  weight = GetWeight(str);
  length = strlen(str);
  if (!weight) {
    mpz_set_ui(*result, 0);
    *done = 0;
    return 0;
  }
  if (str[0] == 'N') {
    for (j = 0; j < length; j++)
      if (str[j] == 'P')
        str[j] = 'N';
      else if (str[j] == 'N')
        str[j] = 'P';
    *negated = 1;
  } else
    *negated = 0;
  if (weight == 1 && strlen(str) == 1) {
    printf("u%d = u0\n", number);
    *done = 1;
    mpz_set_ui(*result, 1);
    return 0;
  }
  res = my_malloc(sizeof(mpz_t) * weight);
  for (j = 0; j < weight; j++)
    mpz_init(res[j]);
  isfirst = 1;
  if (str[length - 1] == '0')
    localcurrent = weight - 1;
  else
    localcurrent = weight - 2;
  if (localcurrent < 0)
    localcurrent = 0;
  if (str[last] == 'N')
    neg = 1;
  else
    neg = 0;
  do {
    j = last + 1;
    while (str[j++] == '0')
      ;
    j--;
    if (j - last) {
      if (isfirst) {
        if (str[j] == 'P' && !neg) {
          if (localcurrent)
            printf("u%d = u0 << %d + u0\n", indice + localcurrent, j - last);
          else
            printf("u%d = u0 << %d + u0\n", number, j - last);
          mpz_mul_2exp(tempmpz, un, j - last);
          mpz_add(res[localcurrent], tempmpz, un);
          mpz_out_str(stdout, 2, res[localcurrent]);
          printf("\n");
          cost++;
          *done = 1;
          localcurrent--;
          isfirst = 0;
        }
        if (str[j] == 0 && j - last - 1) {
          if (localcurrent)
            printf("u%d = u0 << %d\n", indice + localcurrent, j - last);
          else
            printf("u%d = u0 << %d\n", number, j - last);
          mpz_mul_2exp(res[localcurrent], un, j - last - 1);
          mpz_out_str(stdout, 2, res[localcurrent]);
          printf("\n");
          localcurrent--;
          *done = 1;
          isfirst = 0;
        }
        if (str[j] == 'N' || neg) {
          if (localcurrent)
            printf("u%d = u0 << %d - u0\n", indice + localcurrent, j - last);
          else
            printf("u%d = u0 << %d - u0\n", number, j - last);
          mpz_mul_2exp(tempmpz, un, j - last);
          mpz_sub(res[localcurrent], tempmpz, un);
          mpz_out_str(stdout, 2, res[localcurrent]);
          printf("\n");
          cost++;
          neg = 0;
          *done = 1;
          localcurrent--;
          isfirst = 0;
        }
      } else {
        if (str[j] == 'P' && !neg) {
          if (localcurrent)
            printf("u%d = u%d << %d + u0\n", indice + localcurrent,
                   indice + localcurrent + 1, j - last);
          else
            printf("u%d = u%d << %d + u0\n", number, indice + localcurrent + 1,
                   j - last);
          mpz_mul_2exp(tempmpz, res[localcurrent + 1], j - last);
          mpz_add(res[localcurrent], tempmpz, un);
          mpz_out_str(stdout, 2, res[localcurrent]);
          printf("\n");
          cost++;
          localcurrent--;
          *done = 1;
        }
        if (str[j] == 0 && j - last - 1) {
          if (localcurrent)
            printf("u%d = u%d << %d\n", indice + localcurrent,
                   indice + localcurrent + 1, j - last - 1);
          else
            printf("u%d = u%d << %d\n", number, indice + localcurrent + 1,
                   j - last - 1);
          mpz_mul_2exp(res[localcurrent], res[localcurrent + 1], j - last - 1);
          mpz_out_str(stdout, 2, res[localcurrent]);
          printf("\n");
          localcurrent--;
          *done = 1;
        }
        if (str[j] == 'N' || neg) {
          if (localcurrent)
            printf("u%d = u%d << %d - u0\n", indice + localcurrent,
                   indice + localcurrent + 1, j - last);
          else
            printf("u%d = u%d << %d - u0\n", number, indice + localcurrent + 1,
                   j - last);
          mpz_mul_2exp(tempmpz, res[localcurrent + 1], j - last);
          mpz_sub(res[localcurrent], tempmpz, un);
          mpz_out_str(stdout, 2, res[localcurrent]);
          printf("\n");
          *done = 1;
          cost++;
          neg = 0;
          localcurrent--;
        }
      }
    }
    last = j;
  } while (j < length);
  mpz_set(*result, res[0]);
  mpz_clear(un);
  mpz_clear(tempmpz);
  for (j = 0; j < weight; j++)
    mpz_clear(res[j]);
  free(res);
  return cost;
}


x86 assembly (clang, -O0):
<DoSingleNumberSAS>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
mov    -0x58(%rbp),%edi
mov    $0x1,%esi
call   10e0 <mpz_init_set_ui@plt>
mov    -0x5c(%rbp),%edi
call   1090 <mpz_init@plt>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x10(%rbp),%rdi
call   10a0 <GetWeight@plt>
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rdi
call   1070 <strlen@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x44(%rbp)
jne    1267 <DoSingleNumberSAS+0x87>
mov    -0x30(%rbp),%rax
mov    (%rax),%edi
xor    %esi,%esi
call   10f0 <mpz_set_ui@plt>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1a10 <DoSingleNumberSAS+0x830>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x4e,%eax
jne    12f8 <DoSingleNumberSAS+0x118>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    12e9 <DoSingleNumberSAS+0x109>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x50,%eax
jne    12b0 <DoSingleNumberSAS+0xd0>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movb   $0x4e,(%rax,%rcx,1)
jmp    12d6 <DoSingleNumberSAS+0xf6>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    12d1 <DoSingleNumberSAS+0xf1>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movb   $0x50,(%rax,%rcx,1)
jmp    12d6 <DoSingleNumberSAS+0xf6>
jmp    12db <DoSingleNumberSAS+0xfb>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    127e <DoSingleNumberSAS+0x9e>
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
jmp    1302 <DoSingleNumberSAS+0x122>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
cmpl   $0x1,-0x44(%rbp)
jne    1355 <DoSingleNumberSAS+0x175>
mov    -0x10(%rbp),%rdi
call   1070 <strlen@plt>
cmp    $0x1,%eax
jne    1355 <DoSingleNumberSAS+0x175>
mov    -0x14(%rbp),%esi
lea    0xcd8(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%edi
mov    $0x1,%esi
call   10f0 <mpz_set_ui@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a10 <DoSingleNumberSAS+0x830>
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <my_malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1399 <DoSingleNumberSAS+0x1b9>
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1090 <mpz_init@plt>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    136f <DoSingleNumberSAS+0x18f>
movb   $0x1,-0x51(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    13c5 <DoSingleNumberSAS+0x1e5>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13ce <DoSingleNumberSAS+0x1ee>
mov    -0x44(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jge    13df <DoSingleNumberSAS+0x1ff>
movl   $0x0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    13fd <DoSingleNumberSAS+0x21d>
movb   $0x1,-0x35(%rbp)
jmp    1401 <DoSingleNumberSAS+0x221>
movb   $0x0,-0x35(%rbp)
jmp    1406 <DoSingleNumberSAS+0x226>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    1433 <DoSingleNumberSAS+0x253>
jmp    140f <DoSingleNumberSAS+0x22f>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
cmp    $0x0,%eax
je     199d <DoSingleNumberSAS+0x7bd>
cmpb   $0x0,-0x51(%rbp)
je     16cb <DoSingleNumberSAS+0x4eb>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x50,%eax
jne    1527 <DoSingleNumberSAS+0x347>
cmpb   $0x0,-0x35(%rbp)
jne    1527 <DoSingleNumberSAS+0x347>
cmpl   $0x0,-0x48(%rbp)
je     149d <DoSingleNumberSAS+0x2bd>
mov    -0x34(%rbp),%esi
add    -0x48(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
lea    0xb79(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    14b4 <DoSingleNumberSAS+0x2d4>
mov    -0x14(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
lea    0xb5d(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x5c(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
call   10b0 <mpz_mul_2exp@plt>
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x5c(%rbp),%esi
mov    -0x58(%rbp),%edx
call   10c0 <mpz_add@plt>
mov    0x2afe(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    $0x2,%esi
call   10d0 <mpz_out_str@plt>
lea    0xb1d(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
movb   $0x0,-0x51(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    15ed <DoSingleNumberSAS+0x40d>
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
je     15ed <DoSingleNumberSAS+0x40d>
cmpl   $0x0,-0x48(%rbp)
je     1577 <DoSingleNumberSAS+0x397>
mov    -0x34(%rbp),%esi
add    -0x48(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
lea    0xab4(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    158e <DoSingleNumberSAS+0x3ae>
mov    -0x14(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
lea    0xa98(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x58(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
sub    $0x1,%edx
call   10b0 <mpz_mul_2exp@plt>
mov    0x2a2f(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    $0x2,%esi
call   10d0 <mpz_out_str@plt>
lea    0xa4e(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
movb   $0x0,-0x51(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
je     160f <DoSingleNumberSAS+0x42f>
movsbl -0x35(%rbp),%eax
cmp    $0x0,%eax
je     16c6 <DoSingleNumberSAS+0x4e6>
cmpl   $0x0,-0x48(%rbp)
je     1638 <DoSingleNumberSAS+0x458>
mov    -0x34(%rbp),%esi
add    -0x48(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
lea    0xa03(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    164f <DoSingleNumberSAS+0x46f>
mov    -0x14(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
lea    0x9e7(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x5c(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
call   10b0 <mpz_mul_2exp@plt>
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x5c(%rbp),%esi
mov    -0x58(%rbp),%edx
call   1060 <mpz_sub@plt>
mov    0x2963(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    $0x2,%esi
call   10d0 <mpz_out_str@plt>
lea    0x982(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movb   $0x0,-0x35(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
movb   $0x0,-0x51(%rbp)
jmp    1998 <DoSingleNumberSAS+0x7b8>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x50,%eax
jne    17b8 <DoSingleNumberSAS+0x5d8>
cmpb   $0x0,-0x35(%rbp)
jne    17b8 <DoSingleNumberSAS+0x5d8>
cmpl   $0x0,-0x48(%rbp)
je     171c <DoSingleNumberSAS+0x53c>
mov    -0x34(%rbp),%esi
add    -0x48(%rbp),%esi
mov    -0x34(%rbp),%edx
add    -0x48(%rbp),%edx
add    $0x1,%edx
mov    -0x40(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
lea    0x934(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    173c <DoSingleNumberSAS+0x55c>
mov    -0x14(%rbp),%esi
mov    -0x34(%rbp),%edx
add    -0x48(%rbp),%edx
add    $0x1,%edx
mov    -0x40(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
lea    0x90f(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x5c(%rbp),%edi
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
call   10b0 <mpz_mul_2exp@plt>
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x5c(%rbp),%esi
mov    -0x58(%rbp),%edx
call   10c0 <mpz_add@plt>
mov    0x2869(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    $0x2,%esi
call   10d0 <mpz_out_str@plt>
lea    0x888(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    189f <DoSingleNumberSAS+0x6bf>
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
je     189f <DoSingleNumberSAS+0x6bf>
cmpl   $0x0,-0x48(%rbp)
je     1814 <DoSingleNumberSAS+0x634>
mov    -0x34(%rbp),%esi
add    -0x48(%rbp),%esi
mov    -0x34(%rbp),%edx
add    -0x48(%rbp),%edx
add    $0x1,%edx
mov    -0x40(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
lea    0x852(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    1837 <DoSingleNumberSAS+0x657>
mov    -0x14(%rbp),%esi
mov    -0x34(%rbp),%edx
add    -0x48(%rbp),%edx
add    $0x1,%edx
mov    -0x40(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
lea    0x82a(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
sub    $0x1,%edx
call   10b0 <mpz_mul_2exp@plt>
mov    0x2779(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    $0x2,%esi
call   10d0 <mpz_out_str@plt>
lea    0x798(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
je     18c1 <DoSingleNumberSAS+0x6e1>
movsbl -0x35(%rbp),%eax
cmp    $0x0,%eax
je     1993 <DoSingleNumberSAS+0x7b3>
cmpl   $0x0,-0x48(%rbp)
je     18f3 <DoSingleNumberSAS+0x713>
mov    -0x34(%rbp),%esi
add    -0x48(%rbp),%esi
mov    -0x34(%rbp),%edx
add    -0x48(%rbp),%edx
add    $0x1,%edx
mov    -0x40(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
lea    0x784(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    1913 <DoSingleNumberSAS+0x733>
mov    -0x14(%rbp),%esi
mov    -0x34(%rbp),%edx
add    -0x48(%rbp),%edx
add    $0x1,%edx
mov    -0x40(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
lea    0x75f(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x5c(%rbp),%edi
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x40(%rbp),%edx
sub    -0x3c(%rbp),%edx
call   10b0 <mpz_mul_2exp@plt>
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x5c(%rbp),%esi
mov    -0x58(%rbp),%edx
call   1060 <mpz_sub@plt>
mov    0x2692(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    $0x2,%esi
call   10d0 <mpz_out_str@plt>
lea    0x6b1(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movb   $0x0,-0x35(%rbp)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
jmp    1998 <DoSingleNumberSAS+0x7b8>
jmp    199d <DoSingleNumberSAS+0x7bd>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jl     1406 <DoSingleNumberSAS+0x226>
mov    -0x30(%rbp),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
mov    (%rax),%esi
call   1050 <mpz_set@plt>
mov    -0x58(%rbp),%edi
call   1100 <mpz_clear@plt>
mov    -0x5c(%rbp),%edi
call   1100 <mpz_clear@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1a01 <DoSingleNumberSAS+0x821>
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1100 <mpz_clear@plt>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    19d7 <DoSingleNumberSAS+0x7f7>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DoSingleNumberSAS>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x20(%rsp)
mov    %r8,%r14
mov    %rcx,%r12
mov    %rdx,%rbx
mov    %esi,0x4(%rsp)
mov    %rdi,%rbp
mov    $0x1,%esi
call   10f0 <mpz_init_set_ui@plt>
call   10a0 <mpz_init@plt>
mov    %rbp,%rdi
call   10b0 <GetWeight@plt>
mov    %eax,%r15d
mov    %rbp,%rdi
call   1080 <strlen@plt>
mov    %eax,0x8(%rsp)
test   %r15d,%r15d
je     12df <DoSingleNumberSAS+0xef>
mov    %rbx,0x28(%rsp)
xor    %esi,%esi
cmpb   $0x4e,0x0(%rbp)
jne    1292 <DoSingleNumberSAS+0xa2>
mov    $0x1,%esi
mov    0x8(%rsp),%eax
test   %eax,%eax
jle    1292 <DoSingleNumberSAS+0xa2>
mov    %eax,%ecx
mov    $0x4e,%bl
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x4e,%al
cmp    $0x50,%bl
je     127e <DoSingleNumberSAS+0x8e>
cmp    $0x4e,%bl
jne    1282 <DoSingleNumberSAS+0x92>
mov    $0x50,%al
mov    %al,-0x1(%rbp,%rdx,1)
cmp    %rdx,%rcx
je     1292 <DoSingleNumberSAS+0xa2>
movzbl 0x0(%rbp,%rdx,1),%ebx
add    $0x1,%rdx
jmp    1270 <DoSingleNumberSAS+0x80>
mov    %esi,(%r12)
cmp    $0x1,%r15d
mov    %rbp,0x38(%rsp)
jne    12f6 <DoSingleNumberSAS+0x106>
mov    %rbp,%rdi
call   1080 <strlen@plt>
cmp    $0x1,%eax
jne    131f <DoSingleNumberSAS+0x12f>
lea    0xd4b(%rip),%rdi
xor    %ebp,%ebp
mov    0x4(%rsp),%esi
xor    %eax,%eax
call   1090 <printf@plt>
mov    0x28(%rsp),%rax
movl   $0x1,(%rax)
mov    (%r14),%edi
mov    $0x1,%esi
call   1100 <mpz_set_ui@plt>
jmp    183e <DoSingleNumberSAS+0x64e>
mov    (%r14),%edi
xor    %ebp,%ebp
xor    %esi,%esi
call   1100 <mpz_set_ui@plt>
movl   $0x0,(%rbx)
jmp    183e <DoSingleNumberSAS+0x64e>
lea    0x0(,%r15,4),%edi
call   1040 <my_malloc@plt>
mov    %rax,%r12
test   %r15d,%r15d
jg     132f <DoSingleNumberSAS+0x13f>
mov    %r12,0x18(%rsp)
mov    %r14,0x48(%rsp)
movl   $0x0,0x40(%rsp)
jmp    135d <DoSingleNumberSAS+0x16d>
lea    0x0(,%r15,4),%edi
call   1040 <my_malloc@plt>
mov    %rax,%r12
mov    %r14,0x48(%rsp)
mov    %r15d,%ebx
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%r12,%rbp,4),%edi
call   10a0 <mpz_init@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1340 <DoSingleNumberSAS+0x150>
mov    %r12,0x18(%rsp)
mov    $0x1,%al
mov    %eax,0x40(%rsp)
mov    0x8(%rsp),%esi
movslq %esi,%rax
xor    %ecx,%ecx
mov    0x38(%rsp),%rdx
cmpb   $0x30,-0x1(%rax,%rdx,1)
sete   %cl
mov    %r15,0x50(%rsp)
lea    (%rcx,%r15,1),%r12d
add    $0xfffffffe,%r12d
xor    %eax,%eax
test   %r12d,%r12d
cmovs  %eax,%r12d
cmpb   $0x4e,(%rdx)
sete   %dil
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x34(%rsp)
mov    $0x1,%r15b
xor    %ecx,%ecx
movl   $0x0,0x10(%rsp)
jmp    1439 <DoSingleNumberSAS+0x249>
mov    0x20(%rsp),%rax
lea    (%r12,%rax,1),%esi
mov    %r12d,%r15d
sub    $0x1,%r15d
cmovb  0x4(%rsp),%esi
lea    0xc65(%rip),%rdi
mov    %r14d,%edx
xor    %eax,%eax
call   1090 <printf@plt>
mov    %r14d,%edx
call   10c0 <mpz_mul_2exp@plt>
movslq %r12d,%rbp
mov    0x18(%rsp),%rbx
mov    (%rbx,%rbp,4),%edi
call   1070 <mpz_sub@plt>
mov    0x2bed(%rip),%rax
mov    (%rax),%edi
mov    (%rbx,%rbp,4),%edx
mov    $0x2,%esi
call   10e0 <mpz_out_str@plt>
mov    $0xa,%edi
call   1050 <putchar@plt>
xor    %edi,%edi
addl   $0x1,0x10(%rsp)
mov    0x28(%rsp),%rax
movl   $0x1,(%rax)
mov    %r15d,%r12d
xor    %r15d,%r15d
mov    0x38(%rsp),%rdx
mov    0x8(%rsp),%esi
mov    0x14(%rsp),%ecx
cmp    %ecx,%esi
jle    17eb <DoSingleNumberSAS+0x5fb>
movslq %ecx,%rbx
add    %rdx,%rbx
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
add    $0xffffffff,%r13d
cmp    $0x30,%al
je     1450 <DoSingleNumberSAS+0x260>
sub    %r13d,%ecx
test   %r13d,%r13d
je     1431 <DoSingleNumberSAS+0x241>
mov    %ecx,0x14(%rsp)
mov    %r13d,%r14d
neg    %r14d
mov    %eax,%ecx
xor    $0x50,%cl
or     %dil,%cl
setne  %cl
test   %r15b,%r15b
je     14b0 <DoSingleNumberSAS+0x2c0>
mov    $0x1,%r15b
test   %cl,%cl
je     14db <DoSingleNumberSAS+0x2eb>
test   %al,%al
je     1562 <DoSingleNumberSAS+0x372>
cmp    $0x4e,%al
je     13ae <DoSingleNumberSAS+0x1be>
test   %dil,%dil
jne    13ae <DoSingleNumberSAS+0x1be>
xor    %edi,%edi
jmp    1424 <DoSingleNumberSAS+0x234>
nopl   0x0(%rax)
test   %cl,%cl
je     15fb <DoSingleNumberSAS+0x40b>
test   %al,%al
je     16ad <DoSingleNumberSAS+0x4bd>
cmp    $0x4e,%al
je     175b <DoSingleNumberSAS+0x56b>
test   %dil,%dil
jne    175b <DoSingleNumberSAS+0x56b>
xor    %edi,%edi
xor    %r15d,%r15d
jmp    1429 <DoSingleNumberSAS+0x239>
mov    0x20(%rsp),%rax
lea    (%r12,%rax,1),%esi
test   %r12d,%r12d
cmove  0x4(%rsp),%esi
xor    %r15d,%r15d
mov    %edi,0xc(%rsp)
lea    0xb10(%rip),%rdi
mov    %r14d,%edx
xor    %eax,%eax
call   1090 <printf@plt>
mov    %r14d,%edx
call   10c0 <mpz_mul_2exp@plt>
movslq %r12d,%r12
mov    0x18(%rsp),%rbp
mov    0x0(%rbp,%r12,4),%edi
call   10d0 <mpz_add@plt>
mov    0x2abb(%rip),%rax
mov    (%rax),%edi
mov    0x0(%rbp,%r12,4),%edx
mov    $0x2,%esi
call   10e0 <mpz_out_str@plt>
mov    $0xa,%edi
call   1050 <putchar@plt>
mov    0xc(%rsp),%edi
addl   $0x1,0x10(%rsp)
mov    0x28(%rsp),%rax
movl   $0x1,(%rax)
add    $0xffffffff,%r12d
mov    (%rbx),%al
test   %al,%al
jne    1491 <DoSingleNumberSAS+0x2a1>
cmp    $0xffffffff,%r13d
je     161d <DoSingleNumberSAS+0x42d>
not    %r13d
mov    0x20(%rsp),%rax
lea    (%r12,%rax,1),%esi
mov    %r12d,%eax
sub    $0x1,%eax
mov    %eax,0x44(%rsp)
cmovb  0x4(%rsp),%esi
xor    %r15d,%r15d
mov    %edi,0xc(%rsp)
lea    0xa8a(%rip),%rdi
mov    %r14d,%edx
xor    %eax,%eax
call   1090 <printf@plt>
movslq %r12d,%r12
mov    0x18(%rsp),%rbp
mov    0x0(%rbp,%r12,4),%edi
mov    %r13d,%edx
call   10c0 <mpz_mul_2exp@plt>
mov    0x2a25(%rip),%rax
mov    (%rax),%edi
mov    0x0(%rbp,%r12,4),%edx
mov    $0x2,%esi
call   10e0 <mpz_out_str@plt>
mov    $0xa,%edi
call   1050 <putchar@plt>
mov    0xc(%rsp),%edi
mov    0x28(%rsp),%rax
movl   $0x1,(%rax)
mov    (%rbx),%al
mov    0x44(%rsp),%ecx
mov    %ecx,%r12d
cmp    $0x4e,%al
jne    1499 <DoSingleNumberSAS+0x2a9>
jmp    13ae <DoSingleNumberSAS+0x1be>
test   %r12d,%r12d
mov    %edi,0xc(%rsp)
je     162c <DoSingleNumberSAS+0x43c>
mov    0x20(%rsp),%rax
lea    (%r12,%rax,1),%esi
lea    (%r12,%rax,1),%edx
add    $0x1,%edx
lea    0xa29(%rip),%rdi
jmp    163b <DoSingleNumberSAS+0x44b>
xor    %eax,%eax
cmp    $0x4e,%al
jne    1499 <DoSingleNumberSAS+0x2a9>
jmp    13ae <DoSingleNumberSAS+0x1be>
lea    0xa11(%rip),%rdi
mov    0x4(%rsp),%esi
mov    0x34(%rsp),%edx
mov    %r14d,%ecx
xor    %eax,%eax
call   1090 <printf@plt>
movslq %r12d,%r15
mov    0x18(%rsp),%rbp
mov    0x4(%rbp,%r15,4),%esi
mov    %r14d,%edx
call   10c0 <mpz_mul_2exp@plt>
mov    0x0(%rbp,%r15,4),%edi
call   10d0 <mpz_add@plt>
mov    0x2975(%rip),%rax
mov    (%rax),%edi
mov    0x0(%rbp,%r15,4),%edx
mov    $0x2,%esi
call   10e0 <mpz_out_str@plt>
mov    $0xa,%edi
call   1050 <putchar@plt>
addl   $0x1,0x10(%rsp)
add    $0xffffffff,%r12d
mov    0x28(%rsp),%rax
movl   $0x1,(%rax)
mov    (%rbx),%al
mov    0x38(%rsp),%rdx
mov    0xc(%rsp),%edi
test   %al,%al
jne    14c0 <DoSingleNumberSAS+0x2d0>
cmp    $0xffffffff,%r13d
je     16d8 <DoSingleNumberSAS+0x4e8>
mov    %edi,0xc(%rsp)
not    %r13d
test   %r12d,%r12d
je     16e4 <DoSingleNumberSAS+0x4f4>
mov    0x20(%rsp),%rax
lea    (%r12,%rax,1),%esi
lea    (%r12,%rax,1),%edx
add    $0x1,%edx
lea    0x984(%rip),%rdi
jmp    16f3 <DoSingleNumberSAS+0x503>
xor    %eax,%eax
cmp    $0x4e,%al
jne    14c8 <DoSingleNumberSAS+0x2d8>
jmp    175b <DoSingleNumberSAS+0x56b>
lea    0x96f(%rip),%rdi
mov    0x4(%rsp),%esi
mov    0x34(%rsp),%edx
mov    %r13d,%ecx
xor    %eax,%eax
call   1090 <printf@plt>
movslq %r12d,%r15
mov    0x18(%rsp),%rbp
mov    0x0(%rbp,%r15,4),%edi
mov    0x4(%rbp,%r15,4),%esi
mov    %r13d,%edx
call   10c0 <mpz_mul_2exp@plt>
mov    0x28c2(%rip),%rax
mov    (%rax),%edi
mov    0x0(%rbp,%r15,4),%edx
mov    $0x2,%esi
call   10e0 <mpz_out_str@plt>
mov    $0xa,%edi
call   1050 <putchar@plt>
add    $0xffffffff,%r12d
mov    0x28(%rsp),%rax
movl   $0x1,(%rax)
mov    (%rbx),%al
mov    0x38(%rsp),%rdx
mov    0xc(%rsp),%edi
cmp    $0x4e,%al
jne    14c8 <DoSingleNumberSAS+0x2d8>
test   %r12d,%r12d
je     1779 <DoSingleNumberSAS+0x589>
mov    0x20(%rsp),%rax
lea    (%r12,%rax,1),%esi
lea    (%r12,%rax,1),%edx
add    $0x1,%edx
lea    0x8f4(%rip),%rdi
jmp    1788 <DoSingleNumberSAS+0x598>
lea    0x8eb(%rip),%rdi
mov    0x4(%rsp),%esi
mov    0x34(%rsp),%edx
mov    %r14d,%ecx
xor    %eax,%eax
call   1090 <printf@plt>
movslq %r12d,%rbx
mov    0x18(%rsp),%rbp
mov    0x4(%rbp,%rbx,4),%esi
mov    %r14d,%edx
call   10c0 <mpz_mul_2exp@plt>
mov    0x0(%rbp,%rbx,4),%edi
call   1070 <mpz_sub@plt>
mov    0x282a(%rip),%rax
mov    (%rax),%edi
mov    0x0(%rbp,%rbx,4),%edx
mov    $0x2,%esi
call   10e0 <mpz_out_str@plt>
mov    $0xa,%edi
call   1050 <putchar@plt>
mov    0x28(%rsp),%rax
movl   $0x1,(%rax)
addl   $0x1,0x10(%rsp)
add    $0xffffffff,%r12d
xor    %edi,%edi
jmp    1421 <DoSingleNumberSAS+0x231>
mov    0x48(%rsp),%rax
mov    (%rax),%edi
mov    0x18(%rsp),%r14
mov    (%r14),%esi
call   1060 <mpz_set@plt>
call   1110 <mpz_clear@plt>
call   1110 <mpz_clear@plt>
cmpb   $0x0,0x40(%rsp)
je     1832 <DoSingleNumberSAS+0x642>
mov    0x50(%rsp),%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rbp,4),%edi
call   1110 <mpz_clear@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1820 <DoSingleNumberSAS+0x630>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%ebp
mov    %ebp,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [10 x i8] c"u%d = u0\0A\00"
@.str.1 = [21 x i8] c"u%d = u0 << %d + u0\0A\00"
@stdout = global i32 0
@.str.2 = [2 x i8] c"\0A\00"
@.str.3 = [16 x i8] c"u%d = u0 << %d\0A\00"
@.str.4 = [21 x i8] c"u%d = u0 << %d - u0\0A\00"
@.str.5 = [22 x i8] c"u%d = u%d << %d + u0\0A\00"
@.str.6 = [17 x i8] c"u%d = u%d << %d\0A\00"
@.str.7 = [22 x i8] c"u%d = u%d << %d - u0\0A\00"
define i32 @DoSingleNumberSAS(i8* %0, i32 %1, i32* %2, i32* %3, i32* %4, i32 %5) {
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i8
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i8
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32*
store i8* %0, i8** %8
store i32 %1, i32* %9
store i32* %2, i32** %10
store i32* %3, i32** %11
store i32* %4, i32** %12
store i32 %5, i32* %13
%25 = load i32, i32* %22
%26 = call i32 @mpz_init_set_ui(i32 %25, i32 1)
%27 = load i32, i32* %23
%28 = call i32 @mpz_init(i32 %27)
store i32 0, i32* %15
store i32 0, i32* %20
%29 = load i8*, i8** %8
%30 = call i32 @GetWeight(i8* %29)
store i32 %30, i32* %17
%31 = load i8*, i8** %8
%32 = call i32 @strlen(i8* %31)
store i32 %32, i32* %19
%33 = load i32, i32* %17
%34 = icmp ne i32 %33, 0
br i1 %34, label %40, label %35
35: ; preds = %6
%36 = load i32*, i32** %12
%37 = load i32, i32* %36
%38 = call i32 @mpz_set_ui(i32 %37, i32 0)
%39 = load i32*, i32** %10
store i32 0, i32* %39
store i32 0, i32* %7
br label %586
40: ; preds = %6
%41 = load i8*, i8** %8
%42 = getelementptr inbounds i8, i8* %41, i64 0
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = icmp eq i32 %44, 78
br i1 %45, label %46, label %84
46: ; preds = %40
store i32 0, i32* %16
br label %47
47: ; preds = %79, %46
%48 = load i32, i32* %16
%49 = load i32, i32* %19
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %82
51: ; preds = %47
%52 = load i8*, i8** %8
%53 = load i32, i32* %16
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = icmp eq i32 %57, 80
br i1 %58, label %59, label %64
59: ; preds = %51
%60 = load i8*, i8** %8
%61 = load i32, i32* %16
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %60, i64 %62
store i8 78, i8* %63
br label %78
64: ; preds = %51
%65 = load i8*, i8** %8
%66 = load i32, i32* %16
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %65, i64 %67
%69 = load i8, i8* %68
%70 = sext i8 %69 to i32
%71 = icmp eq i32 %70, 78
br i1 %71, label %72, label %77
72: ; preds = %64
%73 = load i8*, i8** %8
%74 = load i32, i32* %16
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %73, i64 %75
store i8 80, i8* %76
br label %77
77: ; preds = %72, %64
br label %78
78: ; preds = %77, %59
br label %79
79: ; preds = %78
%80 = load i32, i32* %16
%81 = add nsw i32 %80, 1
store i32 %81, i32* %16
br label %47
82: ; preds = %47
%83 = load i32*, i32** %11
store i32 1, i32* %83
br label %86
84: ; preds = %40
%85 = load i32*, i32** %11
store i32 0, i32* %85
br label %86
86: ; preds = %84, %82
%87 = load i32, i32* %17
%88 = icmp eq i32 %87, 1
br i1 %88, label %89, label %100
89: ; preds = %86
%90 = load i8*, i8** %8
%91 = call i32 @strlen(i8* %90)
%92 = icmp eq i32 %91, 1
br i1 %92, label %93, label %100
93: ; preds = %89
%94 = load i32, i32* %9
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i32 %94)
%96 = load i32*, i32** %10
store i32 1, i32* %96
%97 = load i32*, i32** %12
%98 = load i32, i32* %97
%99 = call i32 @mpz_set_ui(i32 %98, i32 1)
store i32 0, i32* %7
br label %586
100: ; preds = %89, %86
%101 = load i32, i32* %17
%102 = sext i32 %101 to i64
%103 = mul i64 4, %102
%104 = trunc i64 %103 to i32
%105 = call i32* @my_malloc(i32 %104)
store i32* %105, i32** %24
store i32 0, i32* %16
br label %106
106: ; preds = %117, %100
%107 = load i32, i32* %16
%108 = load i32, i32* %17
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %120
110: ; preds = %106
%111 = load i32*, i32** %24
%112 = load i32, i32* %16
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %111, i64 %113
%115 = load i32, i32* %114
%116 = call i32 @mpz_init(i32 %115)
br label %117
117: ; preds = %110
%118 = load i32, i32* %16
%119 = add nsw i32 %118, 1
store i32 %119, i32* %16
br label %106
120: ; preds = %106
store i8 1, i8* %21
%121 = load i8*, i8** %8
%122 = load i32, i32* %19
%123 = sub nsw i32 %122, 1
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i8, i8* %121, i64 %124
%126 = load i8, i8* %125
%127 = sext i8 %126 to i32
%128 = icmp eq i32 %127, 48
br i1 %128, label %129, label %132
129: ; preds = %120
%130 = load i32, i32* %17
%131 = sub nsw i32 %130, 1
store i32 %131, i32* %18
br label %135
132: ; preds = %120
%133 = load i32, i32* %17
%134 = sub nsw i32 %133, 2
store i32 %134, i32* %18
br label %135
135: ; preds = %132, %129
%136 = load i32, i32* %18
%137 = icmp slt i32 %136, 0
br i1 %137, label %138, label %139
138: ; preds = %135
store i32 0, i32* %18
br label %139
139: ; preds = %138, %135
%140 = load i8*, i8** %8
%141 = load i32, i32* %15
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i8, i8* %143
%145 = sext i8 %144 to i32
%146 = icmp eq i32 %145, 78
br i1 %146, label %147, label %148
147: ; preds = %139
store i8 1, i8* %14
br label %149
148: ; preds = %139
store i8 0, i8* %14
br label %149
149: ; preds = %148, %147
br label %150
150: ; preds = %553, %149
%151 = load i32, i32* %15
%152 = add nsw i32 %151, 1
store i32 %152, i32* %16
br label %153
153: ; preds = %162, %150
%154 = load i8*, i8** %8
%155 = load i32, i32* %16
%156 = add nsw i32 %155, 1
store i32 %156, i32* %16
%157 = sext i32 %155 to i64
%158 = getelementptr inbounds i8, i8* %154, i64 %157
%159 = load i8, i8* %158
%160 = sext i8 %159 to i32
%161 = icmp eq i32 %160, 48
br i1 %161, label %162, label %163
162: ; preds = %153
br label %153
163: ; preds = %153
%164 = load i32, i32* %16
%165 = add nsw i32 %164, -1
store i32 %165, i32* %16
%166 = load i32, i32* %16
%167 = load i32, i32* %15
%168 = sub nsw i32 %166, %167
%169 = icmp ne i32 %168, 0
br i1 %169, label %170, label %551
170: ; preds = %163
%171 = load i8, i8* %21
%172 = icmp ne i8 %171, 0
br i1 %172, label %173, label %341
173: ; preds = %170
%174 = load i8*, i8** %8
%175 = load i32, i32* %16
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i8, i8* %174, i64 %176
%178 = load i8, i8* %177
%179 = sext i8 %178 to i32
%180 = icmp eq i32 %179, 80
br i1 %180, label %181, label %229
181: ; preds = %173
%182 = load i8, i8* %14
%183 = icmp ne i8 %182, 0
br i1 %183, label %229, label %184
184: ; preds = %181
%185 = load i32, i32* %18
%186 = icmp ne i32 %185, 0
br i1 %186, label %187, label %195
187: ; preds = %184
%188 = load i32, i32* %13
%189 = load i32, i32* %18
%190 = add nsw i32 %188, %189
%191 = load i32, i32* %16
%192 = load i32, i32* %15
%193 = sub nsw i32 %191, %192
%194 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i32 %190, i32 %193)
br label %201
195: ; preds = %184
%196 = load i32, i32* %9
%197 = load i32, i32* %16
%198 = load i32, i32* %15
%199 = sub nsw i32 %197, %198
%200 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i32 %196, i32 %199)
br label %201
201: ; preds = %195, %187
%202 = load i32, i32* %23
%203 = load i32, i32* %22
%204 = load i32, i32* %16
%205 = load i32, i32* %15
%206 = sub nsw i32 %204, %205
%207 = call i32 @mpz_mul_2exp(i32 %202, i32 %203, i32 %206)
%208 = load i32*, i32** %24
%209 = load i32, i32* %18
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32, i32* %208, i64 %210
%212 = load i32, i32* %211
%213 = load i32, i32* %23
%214 = load i32, i32* %22
%215 = call i32 @mpz_add(i32 %212, i32 %213, i32 %214)
%216 = load i32, i32* @stdout
%217 = load i32*, i32** %24
%218 = load i32, i32* %18
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i32, i32* %217, i64 %219
%221 = load i32, i32* %220
%222 = call i32 @mpz_out_str(i32 %216, i32 2, i32 %221)
%223 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%224 = load i32, i32* %20
%225 = add nsw i32 %224, 1
store i32 %225, i32* %20
%226 = load i32*, i32** %10
store i32 1, i32* %226
%227 = load i32, i32* %18
%228 = add nsw i32 %227, -1
store i32 %228, i32* %18
store i8 0, i8* %21
br label %229
229: ; preds = %201, %181, %173
%230 = load i8*, i8** %8
%231 = load i32, i32* %16
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %230, i64 %232
%234 = load i8, i8* %233
%235 = sext i8 %234 to i32
%236 = icmp eq i32 %235, 0
br i1 %236, label %237, label %283
237: ; preds = %229
%238 = load i32, i32* %16
%239 = load i32, i32* %15
%240 = sub nsw i32 %238, %239
%241 = sub nsw i32 %240, 1
%242 = icmp ne i32 %241, 0
br i1 %242, label %243, label %283
243: ; preds = %237
%244 = load i32, i32* %18
%245 = icmp ne i32 %244, 0
br i1 %245, label %246, label %254
246: ; preds = %243
%247 = load i32, i32* %13
%248 = load i32, i32* %18
%249 = add nsw i32 %247, %248
%250 = load i32, i32* %16
%251 = load i32, i32* %15
%252 = sub nsw i32 %250, %251
%253 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0), i32 %249, i32 %252)
br label %260
254: ; preds = %243
%255 = load i32, i32* %9
%256 = load i32, i32* %16
%257 = load i32, i32* %15
%258 = sub nsw i32 %256, %257
%259 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0), i32 %255, i32 %258)
br label %260
260: ; preds = %254, %246
%261 = load i32*, i32** %24
%262 = load i32, i32* %18
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32, i32* %261, i64 %263
%265 = load i32, i32* %264
%266 = load i32, i32* %22
%267 = load i32, i32* %16
%268 = load i32, i32* %15
%269 = sub nsw i32 %267, %268
%270 = sub nsw i32 %269, 1
%271 = call i32 @mpz_mul_2exp(i32 %265, i32 %266, i32 %270)
%272 = load i32, i32* @stdout
%273 = load i32*, i32** %24
%274 = load i32, i32* %18
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i32, i32* %273, i64 %275
%277 = load i32, i32* %276
%278 = call i32 @mpz_out_str(i32 %272, i32 2, i32 %277)
%279 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%280 = load i32, i32* %18
%281 = add nsw i32 %280, -1
store i32 %281, i32* %18
%282 = load i32*, i32** %10
store i32 1, i32* %282
store i8 0, i8* %21
br label %283
283: ; preds = %260, %237, %229
%284 = load i8*, i8** %8
%285 = load i32, i32* %16
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i8, i8* %284, i64 %286
%288 = load i8, i8* %287
%289 = sext i8 %288 to i32
%290 = icmp eq i32 %289, 78
br i1 %290, label %295, label %291
291: ; preds = %283
%292 = load i8, i8* %14
%293 = sext i8 %292 to i32
%294 = icmp ne i32 %293, 0
br i1 %294, label %295, label %340
295: ; preds = %291, %283
%296 = load i32, i32* %18
%297 = icmp ne i32 %296, 0
br i1 %297, label %298, label %306
298: ; preds = %295
%299 = load i32, i32* %13
%300 = load i32, i32* %18
%301 = add nsw i32 %299, %300
%302 = load i32, i32* %16
%303 = load i32, i32* %15
%304 = sub nsw i32 %302, %303
%305 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.4, i64 0, i64 0), i32 %301, i32 %304)
br label %312
306: ; preds = %295
%307 = load i32, i32* %9
%308 = load i32, i32* %16
%309 = load i32, i32* %15
%310 = sub nsw i32 %308, %309
%311 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.4, i64 0, i64 0), i32 %307, i32 %310)
br label %312
312: ; preds = %306, %298
%313 = load i32, i32* %23
%314 = load i32, i32* %22
%315 = load i32, i32* %16
%316 = load i32, i32* %15
%317 = sub nsw i32 %315, %316
%318 = call i32 @mpz_mul_2exp(i32 %313, i32 %314, i32 %317)
%319 = load i32*, i32** %24
%320 = load i32, i32* %18
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds i32, i32* %319, i64 %321
%323 = load i32, i32* %322
%324 = load i32, i32* %23
%325 = load i32, i32* %22
%326 = call i32 @mpz_sub(i32 %323, i32 %324, i32 %325)
%327 = load i32, i32* @stdout
%328 = load i32*, i32** %24
%329 = load i32, i32* %18
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds i32, i32* %328, i64 %330
%332 = load i32, i32* %331
%333 = call i32 @mpz_out_str(i32 %327, i32 2, i32 %332)
%334 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%335 = load i32, i32* %20
%336 = add nsw i32 %335, 1
store i32 %336, i32* %20
store i8 0, i8* %14
%337 = load i32*, i32** %10
store i32 1, i32* %337
%338 = load i32, i32* %18
%339 = add nsw i32 %338, -1
store i32 %339, i32* %18
store i8 0, i8* %21
br label %340
340: ; preds = %312, %291
br label %550
341: ; preds = %170
%342 = load i8*, i8** %8
%343 = load i32, i32* %16
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds i8, i8* %342, i64 %344
%346 = load i8, i8* %345
%347 = sext i8 %346 to i32
%348 = icmp eq i32 %347, 80
br i1 %348, label %349, label %410
349: ; preds = %341
%350 = load i8, i8* %14
%351 = icmp ne i8 %350, 0
br i1 %351, label %410, label %352
352: ; preds = %349
%353 = load i32, i32* %18
%354 = icmp ne i32 %353, 0
br i1 %354, label %355, label %367
355: ; preds = %352
%356 = load i32, i32* %13
%357 = load i32, i32* %18
%358 = add nsw i32 %356, %357
%359 = load i32, i32* %13
%360 = load i32, i32* %18
%361 = add nsw i32 %359, %360
%362 = add nsw i32 %361, 1
%363 = load i32, i32* %16
%364 = load i32, i32* %15
%365 = sub nsw i32 %363, %364
%366 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0), i32 %358, i32 %362, i32 %365)
br label %377
367: ; preds = %352
%368 = load i32, i32* %9
%369 = load i32, i32* %13
%370 = load i32, i32* %18
%371 = add nsw i32 %369, %370
%372 = add nsw i32 %371, 1
%373 = load i32, i32* %16
%374 = load i32, i32* %15
%375 = sub nsw i32 %373, %374
%376 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0), i32 %368, i32 %372, i32 %375)
br label %377
377: ; preds = %367, %355
%378 = load i32, i32* %23
%379 = load i32*, i32** %24
%380 = load i32, i32* %18
%381 = add nsw i32 %380, 1
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds i32, i32* %379, i64 %382
%384 = load i32, i32* %383
%385 = load i32, i32* %16
%386 = load i32, i32* %15
%387 = sub nsw i32 %385, %386
%388 = call i32 @mpz_mul_2exp(i32 %378, i32 %384, i32 %387)
%389 = load i32*, i32** %24
%390 = load i32, i32* %18
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i32, i32* %389, i64 %391
%393 = load i32, i32* %392
%394 = load i32, i32* %23
%395 = load i32, i32* %22
%396 = call i32 @mpz_add(i32 %393, i32 %394, i32 %395)
%397 = load i32, i32* @stdout
%398 = load i32*, i32** %24
%399 = load i32, i32* %18
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i32, i32* %398, i64 %400
%402 = load i32, i32* %401
%403 = call i32 @mpz_out_str(i32 %397, i32 2, i32 %402)
%404 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%405 = load i32, i32* %20
%406 = add nsw i32 %405, 1
store i32 %406, i32* %20
%407 = load i32, i32* %18
%408 = add nsw i32 %407, -1
store i32 %408, i32* %18
%409 = load i32*, i32** %10
store i32 1, i32* %409
br label %410
410: ; preds = %377, %349, %341
%411 = load i8*, i8** %8
%412 = load i32, i32* %16
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i8, i8* %411, i64 %413
%415 = load i8, i8* %414
%416 = sext i8 %415 to i32
%417 = icmp eq i32 %416, 0
br i1 %417, label %418, label %479
418: ; preds = %410
%419 = load i32, i32* %16
%420 = load i32, i32* %15
%421 = sub nsw i32 %419, %420
%422 = sub nsw i32 %421, 1
%423 = icmp ne i32 %422, 0
br i1 %423, label %424, label %479
424: ; preds = %418
%425 = load i32, i32* %18
%426 = icmp ne i32 %425, 0
br i1 %426, label %427, label %440
427: ; preds = %424
%428 = load i32, i32* %13
%429 = load i32, i32* %18
%430 = add nsw i32 %428, %429
%431 = load i32, i32* %13
%432 = load i32, i32* %18
%433 = add nsw i32 %431, %432
%434 = add nsw i32 %433, 1
%435 = load i32, i32* %16
%436 = load i32, i32* %15
%437 = sub nsw i32 %435, %436
%438 = sub nsw i32 %437, 1
%439 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0), i32 %430, i32 %434, i32 %438)
br label %451
440: ; preds = %424
%441 = load i32, i32* %9
%442 = load i32, i32* %13
%443 = load i32, i32* %18
%444 = add nsw i32 %442, %443
%445 = add nsw i32 %444, 1
%446 = load i32, i32* %16
%447 = load i32, i32* %15
%448 = sub nsw i32 %446, %447
%449 = sub nsw i32 %448, 1
%450 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0), i32 %441, i32 %445, i32 %449)
br label %451
451: ; preds = %440, %427
%452 = load i32*, i32** %24
%453 = load i32, i32* %18
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds i32, i32* %452, i64 %454
%456 = load i32, i32* %455
%457 = load i32*, i32** %24
%458 = load i32, i32* %18
%459 = add nsw i32 %458, 1
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds i32, i32* %457, i64 %460
%462 = load i32, i32* %461
%463 = load i32, i32* %16
%464 = load i32, i32* %15
%465 = sub nsw i32 %463, %464
%466 = sub nsw i32 %465, 1
%467 = call i32 @mpz_mul_2exp(i32 %456, i32 %462, i32 %466)
%468 = load i32, i32* @stdout
%469 = load i32*, i32** %24
%470 = load i32, i32* %18
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds i32, i32* %469, i64 %471
%473 = load i32, i32* %472
%474 = call i32 @mpz_out_str(i32 %468, i32 2, i32 %473)
%475 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%476 = load i32, i32* %18
%477 = add nsw i32 %476, -1
store i32 %477, i32* %18
%478 = load i32*, i32** %10
store i32 1, i32* %478
br label %479
479: ; preds = %451, %418, %410
%480 = load i8*, i8** %8
%481 = load i32, i32* %16
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds i8, i8* %480, i64 %482
%484 = load i8, i8* %483
%485 = sext i8 %484 to i32
%486 = icmp eq i32 %485, 78
br i1 %486, label %491, label %487
487: ; preds = %479
%488 = load i8, i8* %14
%489 = sext i8 %488 to i32
%490 = icmp ne i32 %489, 0
br i1 %490, label %491, label %549
491: ; preds = %487, %479
%492 = load i32, i32* %18
%493 = icmp ne i32 %492, 0
br i1 %493, label %494, label %506
494: ; preds = %491
%495 = load i32, i32* %13
%496 = load i32, i32* %18
%497 = add nsw i32 %495, %496
%498 = load i32, i32* %13
%499 = load i32, i32* %18
%500 = add nsw i32 %498, %499
%501 = add nsw i32 %500, 1
%502 = load i32, i32* %16
%503 = load i32, i32* %15
%504 = sub nsw i32 %502, %503
%505 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.7, i64 0, i64 0), i32 %497, i32 %501, i32 %504)
br label %516
506: ; preds = %491
%507 = load i32, i32* %9
%508 = load i32, i32* %13
%509 = load i32, i32* %18
%510 = add nsw i32 %508, %509
%511 = add nsw i32 %510, 1
%512 = load i32, i32* %16
%513 = load i32, i32* %15
%514 = sub nsw i32 %512, %513
%515 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.7, i64 0, i64 0), i32 %507, i32 %511, i32 %514)
br label %516
516: ; preds = %506, %494
%517 = load i32, i32* %23
%518 = load i32*, i32** %24
%519 = load i32, i32* %18
%520 = add nsw i32 %519, 1
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds i32, i32* %518, i64 %521
%523 = load i32, i32* %522
%524 = load i32, i32* %16
%525 = load i32, i32* %15
%526 = sub nsw i32 %524, %525
%527 = call i32 @mpz_mul_2exp(i32 %517, i32 %523, i32 %526)
%528 = load i32*, i32** %24
%529 = load i32, i32* %18
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds i32, i32* %528, i64 %530
%532 = load i32, i32* %531
%533 = load i32, i32* %23
%534 = load i32, i32* %22
%535 = call i32 @mpz_sub(i32 %532, i32 %533, i32 %534)
%536 = load i32, i32* @stdout
%537 = load i32*, i32** %24
%538 = load i32, i32* %18
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds i32, i32* %537, i64 %539
%541 = load i32, i32* %540
%542 = call i32 @mpz_out_str(i32 %536, i32 2, i32 %541)
%543 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%544 = load i32*, i32** %10
store i32 1, i32* %544
%545 = load i32, i32* %20
%546 = add nsw i32 %545, 1
store i32 %546, i32* %20
store i8 0, i8* %14
%547 = load i32, i32* %18
%548 = add nsw i32 %547, -1
store i32 %548, i32* %18
br label %549
549: ; preds = %516, %487
br label %550
550: ; preds = %549, %340
br label %551
551: ; preds = %550, %163
%552 = load i32, i32* %16
store i32 %552, i32* %15
br label %553
553: ; preds = %551
%554 = load i32, i32* %16
%555 = load i32, i32* %19
%556 = icmp slt i32 %554, %555
br i1 %556, label %150, label %557
557: ; preds = %553
%558 = load i32*, i32** %12
%559 = load i32, i32* %558
%560 = load i32*, i32** %24
%561 = getelementptr inbounds i32, i32* %560, i64 0
%562 = load i32, i32* %561
%563 = call i32 @mpz_set(i32 %559, i32 %562)
%564 = load i32, i32* %22
%565 = call i32 @mpz_clear(i32 %564)
%566 = load i32, i32* %23
%567 = call i32 @mpz_clear(i32 %566)
store i32 0, i32* %16
br label %568
568: ; preds = %579, %557
%569 = load i32, i32* %16
%570 = load i32, i32* %17
%571 = icmp slt i32 %569, %570
br i1 %571, label %572, label %582
572: ; preds = %568
%573 = load i32*, i32** %24
%574 = load i32, i32* %16
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds i32, i32* %573, i64 %575
%577 = load i32, i32* %576
%578 = call i32 @mpz_clear(i32 %577)
br label %579
579: ; preds = %572
%580 = load i32, i32* %16
%581 = add nsw i32 %580, 1
store i32 %581, i32* %16
br label %568
582: ; preds = %568
%583 = load i32*, i32** %24
%584 = call i32 @free(i32* %583)
%585 = load i32, i32* %20
store i32 %585, i32* %7
br label %586
586: ; preds = %582, %93, %35
%587 = load i32, i32* %7
ret i32 %587
}

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