#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 */
char *calloc(int, int);
int /*<<< orphan*/ debug(double *, double *, int *, int *, int *, int *);
void *floor(double);
int /*<<< orphan*/ free(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ puts(char *);
unsigned int scanf(char *, ...);
unsigned int strlen(char *);
char toupper(char);
int execute(double *memoryPtr, double *accumulatorPtr,
            int *instructionCounterPtr, int *instructionRegisterPtr,
            int *operationCodePtr, int *operandPtr, int debugMode) {
  unsigned int esitoScanf;
  unsigned int buffer;
  unsigned int buffer2;
  char *violation = "*** Simpletron execution abnormally terminated ***";
  char *stringa;
  size_t i;
  puts("*** Program execution begins ***");
  while (*instructionRegisterPtr != -99999) {
    *instructionRegisterPtr = memoryPtr[*instructionCounterPtr];
    *operationCodePtr = *instructionRegisterPtr / 100;
    *operandPtr = *instructionRegisterPtr % 100;
    if (*operationCodePtr == 10) {
      do {
        printf("? ");
        if ((esitoScanf = scanf("%lf", &memoryPtr[*operandPtr])) == 0) {
          scanf("%*[^\n]");
          puts("Attenzione, sono consentiti solo numeri interi.");
        }
      } while (esitoScanf == 0);
    } else if (*operationCodePtr == 11) {
      printf("Risultato dell'elaborazione: %+5lf\n", memoryPtr[*operandPtr]);
    } else if (*operationCodePtr == 20) {
      *accumulatorPtr = memoryPtr[*operandPtr];
    } else if (*operationCodePtr == 21) {
      memoryPtr[*operandPtr] = *accumulatorPtr;
    } else if (*operationCodePtr == 30) {
      *accumulatorPtr += memoryPtr[*operandPtr];
      if (*accumulatorPtr > 9999 || *accumulatorPtr < -9999) {
        puts(violation);
        puts("*** Aritmetic overflow ***");
        return 0;
      }
    } else if (*operationCodePtr == 31) {
      *accumulatorPtr -= memoryPtr[*operandPtr];
      if (*accumulatorPtr < -9999) {
        puts(violation);
        puts("*** Aritmetic overflow ***");
        return 0;
      }
    } else if (*operationCodePtr == 32) {
      if (memoryPtr[*operandPtr] == 0 || *accumulatorPtr == 0) {
        puts(violation);
        puts("*** Attempt to divide by zero ***");
        return 0;
      } else {
        *accumulatorPtr /= memoryPtr[*operandPtr];
      }
    } else if (*operationCodePtr == 52) {
      if (memoryPtr[*operandPtr] == 0 || *accumulatorPtr == 0) {
        puts(violation);
        puts("*** Attempt to divide by zero ***");
        return 0;
      } else {
        buffer = (*accumulatorPtr * 1000);
        buffer2 = (memoryPtr[*operandPtr] * 1000);
        *accumulatorPtr = ((buffer % buffer2) / 1000);
      }
    } else if (*operationCodePtr == 33) {
      *accumulatorPtr *= memoryPtr[*operandPtr];
      if (*accumulatorPtr > 9999 || *accumulatorPtr < -9999) {
        puts(violation);
        puts("*** Aritmetic overflow ***");
        return 0;
      }
    } else if (*operationCodePtr == 53) {
      *accumulatorPtr *= *accumulatorPtr;
      if (*accumulatorPtr > 9999 || *accumulatorPtr < -9999) {
        puts(violation);
        puts("*** Aritmetic overflow ***");
        return 0;
      }
    } else if (*operationCodePtr == 40) {
      *instructionCounterPtr = *operandPtr - 1;
    } else if (*operationCodePtr == 41) {
      if (*accumulatorPtr < 0) {
        *instructionCounterPtr = *operandPtr - 1;
      }
    } else if (*operationCodePtr == 42) {
      if (*accumulatorPtr == 0) {
        *instructionCounterPtr = *operandPtr - 1;
      }
    } else if (*operationCodePtr == 43) {
      puts("*** Simpletron execution terminated ***");
      return 1;
    } else if (*operationCodePtr == 60) {
      printf("%s", "\n");
    } else if (*operationCodePtr == 61) {
      stringa = calloc(80, sizeof(char));
      puts("Sono consentite solo lettere maiuscole e numeri.");
      scanf("%79s", stringa);
      buffer = ((strlen(stringa)));
      memoryPtr[*operandPtr] = buffer * 100;
      i = 0;
      while (i <= buffer) {
        stringa[i] = toupper(stringa[i]);
        i++;
      }
      i = 0;
      while (i <= buffer) {
        if (i % 2 == 0) {
          memoryPtr[*operandPtr] = (stringa[i] + memoryPtr[*operandPtr]);
          *operandPtr += 1;
        } else {
          memoryPtr[*operandPtr] = (stringa[i] * 100);
        }
        i++;
      }
      free(stringa);
    } else if (*operationCodePtr == 62) {
      stringa = calloc(80, sizeof(int));
      buffer = floor((memoryPtr[*operandPtr] / 100));
      i = 0;
      while (i < buffer) {
        if (i % 2 == 0) {
          printf("%c", stringa[i] = ((int)memoryPtr[*operandPtr] % 100));
          *operandPtr += 1;
        } else {
          printf("%c", stringa[i] = floor((memoryPtr[*operandPtr] / 100)));
        }
        i++;
      }
      puts("");
      free(stringa);
    } else if (*operationCodePtr <= 0) {
      puts("*** Loop detected ***");
      puts(violation);
      return 0;
    } else {
      puts("*** Atempt to use unrecognized operation code ***");
      puts(violation);
      return 0;
    }
    if (debugMode == 1) {
      debug(memoryPtr, accumulatorPtr, instructionCounterPtr,
            instructionRegisterPtr, operationCodePtr, operandPtr);
    }
    ++(*instructionCounterPtr);
  }
  return 1;
}


x86 assembly (clang, -O0):
<execute>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
lea    0xe66(%rip),%rax
mov    %rax,-0x50(%rbp)
lea    0xe8e(%rip),%rdi
call   1050 <puts@plt>
mov    -0x28(%rbp),%rax
cmpl   $0xfffe7961,(%rax)
je     1a82 <execute+0x8f2>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    -0x38(%rbp),%rax
mov    %edx,(%rax)
mov    -0x30(%rbp),%rax
cmpl   $0xa,(%rax)
jne    1294 <execute+0x104>
jmp    122c <execute+0x9c>
lea    0xe41(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x10(%rbp),%rsi
mov    -0x38(%rbp),%rax
movslq (%rax),%rax
shl    $0x3,%rax
add    %rax,%rsi
lea    0xe24(%rip),%rdi
mov    $0x0,%al
call   10a0 <scanf@plt>
mov    %eax,-0x3c(%rbp)
cmp    $0x0,%eax
jne    1280 <execute+0xf0>
lea    0xe0e(%rip),%rdi
mov    $0x0,%al
call   10a0 <scanf@plt>
lea    0xe07(%rip),%rdi
call   1050 <puts@plt>
jmp    1285 <execute+0xf5>
cmpl   $0x0,-0x3c(%rbp)
je     122c <execute+0x9c>
jmp    1a4b <execute+0x8bb>
mov    -0x30(%rbp),%rax
cmpl   $0xb,(%rax)
jne    12c4 <execute+0x134>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xdfa(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
jmp    1a46 <execute+0x8b6>
mov    -0x30(%rbp),%rax
cmpl   $0x14,(%rax)
jne    12ee <execute+0x15e>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1a41 <execute+0x8b1>
mov    -0x30(%rbp),%rax
cmpl   $0x15,(%rax)
jne    1318 <execute+0x188>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a3c <execute+0x8ac>
mov    -0x30(%rbp),%rax
cmpl   $0x1e,(%rax)
jne    1397 <execute+0x207>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xcb7(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1371 <execute+0x1e1>
mov    -0x18(%rbp),%rax
movsd  0xca9(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    1392 <execute+0x202>
mov    -0x50(%rbp),%rdi
call   1050 <puts@plt>
lea    0xd55(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
jmp    1a37 <execute+0x8a7>
mov    -0x30(%rbp),%rax
cmpl   $0x1f,(%rax)
jne    1400 <execute+0x270>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  0xc40(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    13fb <execute+0x26b>
mov    -0x50(%rbp),%rdi
call   1050 <puts@plt>
lea    0xcec(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
jmp    1a32 <execute+0x8a2>
mov    -0x30(%rbp),%rax
cmpl   $0x20,(%rax)
jne    1496 <execute+0x306>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1435 <execute+0x2a5>
jp     1435 <execute+0x2a5>
jmp    1450 <execute+0x2c0>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1471 <execute+0x2e1>
jp     1471 <execute+0x2e1>
mov    -0x50(%rbp),%rdi
call   1050 <puts@plt>
lea    0xc91(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    1a2d <execute+0x89d>
mov    -0x30(%rbp),%rax
cmpl   $0x34,(%rax)
jne    1567 <execute+0x3d7>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14cb <execute+0x33b>
jp     14cb <execute+0x33b>
jmp    14e6 <execute+0x356>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1507 <execute+0x377>
jp     1507 <execute+0x377>
mov    -0x50(%rbp),%rdi
call   1050 <puts@plt>
lea    0xbfb(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xb01(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x44(%rbp),%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,%eax
imul   $0x10624dd3,%rax,%rax
shr    $0x26,%rax
cvtsi2sd %eax,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1a28 <execute+0x898>
mov    -0x30(%rbp),%rax
cmpl   $0x21,(%rax)
jne    15e6 <execute+0x456>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xa68(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     15c0 <execute+0x430>
mov    -0x18(%rbp),%rax
movsd  0xa5a(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    15e1 <execute+0x451>
mov    -0x50(%rbp),%rdi
call   1050 <puts@plt>
lea    0xb06(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
jmp    1a23 <execute+0x893>
mov    -0x30(%rbp),%rax
cmpl   $0x35,(%rax)
jne    165d <execute+0x4cd>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x9f1(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1637 <execute+0x4a7>
mov    -0x18(%rbp),%rax
movsd  0x9e3(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    1658 <execute+0x4c8>
mov    -0x50(%rbp),%rdi
call   1050 <puts@plt>
lea    0xa8f(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
jmp    1a1e <execute+0x88e>
mov    -0x30(%rbp),%rax
cmpl   $0x28,(%rax)
jne    167e <execute+0x4ee>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1a19 <execute+0x889>
mov    -0x30(%rbp),%rax
cmpl   $0x29,(%rax)
jne    16b0 <execute+0x520>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    16ab <execute+0x51b>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1a14 <execute+0x884>
mov    -0x30(%rbp),%rax
cmpl   $0x2a,(%rax)
jne    16ec <execute+0x55c>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16e7 <execute+0x557>
jp     16e7 <execute+0x557>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1a0f <execute+0x87f>
mov    -0x30(%rbp),%rax
cmpl   $0x2b,(%rax)
jne    1711 <execute+0x581>
lea    0xa13(%rip),%rdi
call   1050 <puts@plt>
movl   $0x1,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
mov    -0x30(%rbp),%rax
cmpl   $0x3c,(%rax)
jne    1738 <execute+0x5a8>
lea    0xa16(%rip),%rdi
lea    0x9a8(%rip),%rsi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    1a05 <execute+0x875>
mov    -0x30(%rbp),%rax
cmpl   $0x3d,(%rax)
jne    1890 <execute+0x700>
mov    $0x50,%edi
mov    $0x1,%esi
call   1090 <calloc@plt>
mov    %rax,-0x58(%rbp)
lea    0x9df(%rip),%rdi
call   1050 <puts@plt>
mov    -0x58(%rbp),%rsi
lea    0xa00(%rip),%rdi
xor    %eax,%eax
call   10a0 <scanf@plt>
mov    -0x58(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
imul   $0x64,%eax,%eax
cvtsi2sd %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x40(%rbp),%ecx
cmp    %rcx,%rax
ja     17e4 <execute+0x654>
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
mov    %al,%dl
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    17a5 <execute+0x615>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x40(%rbp),%ecx
cmp    %rcx,%rax
ja     1882 <execute+0x6f2>
mov    -0x60(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    184e <execute+0x6be>
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1871 <execute+0x6e1>
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
imul   $0x64,%eax,%eax
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    17ec <execute+0x65c>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
jmp    1a00 <execute+0x870>
mov    -0x30(%rbp),%rax
cmpl   $0x3e,(%rax)
jne    19ac <execute+0x81c>
mov    $0x50,%edi
mov    $0x4,%esi
call   1090 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x738(%rip),%xmm1
divsd  %xmm1,%xmm0
call   10b0 <floor@plt>
mov    %eax,-0x40(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x40(%rbp),%ecx
cmp    %rcx,%rax
jae    1992 <execute+0x802>
mov    -0x60(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    1944 <execute+0x7b4>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
cvttsd2si (%rax,%rcx,8),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %dl,%al
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%esi
lea    0x847(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1981 <execute+0x7f1>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x6a4(%rip),%xmm1
divsd  %xmm1,%xmm0
call   10b0 <floor@plt>
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%esi
lea    0x7fa(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    18dc <execute+0x74c>
lea    0x73c(%rip),%rdi
call   1050 <puts@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
jmp    19fb <execute+0x86b>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jg     19da <execute+0x84a>
lea    0x7b7(%rip),%rdi
call   1050 <puts@plt>
mov    -0x50(%rbp),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
lea    0x7ac(%rip),%rdi
call   1050 <puts@plt>
mov    -0x50(%rbp),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a89 <execute+0x8f9>
jmp    1a00 <execute+0x870>
jmp    1a05 <execute+0x875>
jmp    1a0a <execute+0x87a>
jmp    1a0f <execute+0x87f>
jmp    1a14 <execute+0x884>
jmp    1a19 <execute+0x889>
jmp    1a1e <execute+0x88e>
jmp    1a23 <execute+0x893>
jmp    1a28 <execute+0x898>
jmp    1a2d <execute+0x89d>
jmp    1a32 <execute+0x8a2>
jmp    1a37 <execute+0x8a7>
jmp    1a3c <execute+0x8ac>
jmp    1a41 <execute+0x8b1>
jmp    1a46 <execute+0x8b6>
jmp    1a4b <execute+0x8bb>
cmpl   $0x1,0x10(%rbp)
jne    1a72 <execute+0x8e2>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
call   1070 <debug@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    11ca <execute+0x3a>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<execute>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,%r14
mov    %r8,%r13
mov    %rcx,%rbx
mov    %rdx,%r12
mov    %rsi,0x8(%rsp)
mov    %rdi,%r15
lea    0xf5e(%rip),%rdi
call   1060 <puts@plt>
mov    $0x1,%ebp
cmpl   $0xfffe7961,(%rbx)
je     1708 <execute+0x568>
mov    (%r12),%eax
xorpd  %xmm2,%xmm2
mov    %rbx,0x18(%rsp)
mov    %r12,0x10(%rsp)
mov    %r13,0x20(%rsp)
jmp    121b <execute+0x7b>
nopl   0x0(%rax,%rax,1)
mov    (%r12),%eax
add    $0x1,%eax
mov    %eax,(%r12)
cmpl   $0xfffe7961,(%rbx)
xorpd  %xmm2,%xmm2
je     16b7 <execute+0x517>
cltq
cvttsd2si (%r15,%rax,8),%eax
mov    %eax,(%rbx)
cltq
imul   $0x51eb851f,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
mov    %eax,0x0(%r13)
movslq (%rbx),%rbp
imul   $0x51eb851f,%rbp,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
imul   $0x64,%eax,%eax
sub    %eax,%ebp
mov    %ebp,(%r14)
mov    0x0(%r13),%eax
lea    -0xa(%rax),%ecx
cmp    $0x34,%ecx
ja     16de <execute+0x53e>
lea    0xdab(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
movslq %ebp,%rax
movsd  (%r15,%rax,8),%xmm0
lea    0xef8(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
jmp    166b <execute+0x4cb>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0xe98(%rip),%rdi
xor    %eax,%eax
call   10b0 <scanf@plt>
lea    0xe91(%rip),%rdi
call   1060 <puts@plt>
lea    0xe77(%rip),%rdi
xor    %eax,%eax
call   1090 <printf@plt>
movslq (%r14),%rax
lea    (%r15,%rax,8),%rsi
lea    0xe65(%rip),%rdi
xor    %eax,%eax
call   10b0 <scanf@plt>
test   %eax,%eax
je     12b0 <execute+0x110>
jmp    1660 <execute+0x4c0>
movslq %ebp,%rax
movsd  (%r15,%rax,8),%xmm0
mov    0x8(%rsp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
jmp    166b <execute+0x4cb>
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm0
movslq %ebp,%rax
movsd  %xmm0,(%r15,%rax,8)
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
jmp    166b <execute+0x4cb>
movslq %ebp,%rax
movsd  (%r15,%rax,8),%xmm0
mov    0x8(%rsp),%rax
addsd  (%rax),%xmm0
jmp    13ba <execute+0x21a>
movslq %ebp,%rax
mov    0x8(%rsp),%rcx
movsd  (%rcx),%xmm0
subsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rcx)
jmp    13cc <execute+0x22c>
movslq %ebp,%rax
movsd  (%r15,%rax,8),%xmm0
ucomisd %xmm2,%xmm0
jne    137b <execute+0x1db>
jnp    16be <execute+0x51e>
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm1
ucomisd %xmm2,%xmm1
jne    1390 <execute+0x1f0>
jnp    16be <execute+0x51e>
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
jmp    166b <execute+0x4cb>
movslq %ebp,%rax
movsd  (%r15,%rax,8),%xmm0
mov    0x8(%rsp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
ucomisd 0xc42(%rip),%xmm0
ja     16ce <execute+0x52e>
movsd  0xc3c(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1660 <execute+0x4c0>
jmp    16ce <execute+0x52e>
mov    0x8(%rsp),%rax
ucomisd (%rax),%xmm2
ja     140c <execute+0x26c>
jmp    1660 <execute+0x4c0>
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm2,%xmm0
jne    1660 <execute+0x4c0>
jp     1660 <execute+0x4c0>
add    $0xffffffff,%ebp
mov    %ebp,(%r12)
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
jmp    166b <execute+0x4cb>
movslq %ebp,%rax
movsd  (%r15,%rax,8),%xmm0
ucomisd %xmm2,%xmm0
jne    1438 <execute+0x298>
jnp    16be <execute+0x51e>
mov    0x8(%rsp),%rsi
movsd  (%rsi),%xmm1
ucomisd %xmm2,%xmm1
jne    144d <execute+0x2ad>
jnp    16be <execute+0x51e>
movsd  0xbc3(%rip),%xmm2
mulsd  %xmm2,%xmm1
cvttsd2si %xmm1,%rax
mulsd  %xmm2,%xmm0
cvttsd2si %xmm0,%rcx
xor    %edx,%edx
div    %ecx
imul   $0x10624dd3,%rdx,%rax
shr    $0x26,%rax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rsi)
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
jmp    166b <execute+0x4cb>
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rax)
ucomisd 0xb5e(%rip),%xmm0
jbe    1660 <execute+0x4c0>
jmp    16ce <execute+0x52e>
mov    $0xa,%edi
call   1040 <putchar@plt>
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
jmp    166b <execute+0x4cb>
mov    $0x50,%edi
mov    $0x1,%esi
call   10a0 <calloc@plt>
mov    %rax,%rbp
lea    0xd27(%rip),%rdi
call   1060 <puts@plt>
lea    0xd4c(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <scanf@plt>
mov    %rbp,%rdi
call   1070 <strlen@plt>
imul   $0x64,%eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %rcx,%xmm0
movslq (%r14),%rcx
movsd  %xmm0,(%r15,%rcx,8)
mov    %eax,%r12d
add    $0x1,%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl 0x0(%rbp,%rbx,1),%edi
call   1050 <toupper@plt>
mov    %al,0x0(%rbp,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1530 <execute+0x390>
xor    %eax,%eax
mov    0x18(%rsp),%rbx
jmp    1570 <execute+0x3d0>
imul   $0x64,%ecx,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movslq (%r14),%rcx
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%rax
cmp    %rax,%r12
je     1648 <execute+0x4a8>
movsbl 0x0(%rbp,%rax,1),%ecx
test   $0x1,%al
jne    1550 <execute+0x3b0>
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movslq (%r14),%rcx
addsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%ecx
mov    %ecx,(%r14)
jmp    1563 <execute+0x3c3>
mov    $0x50,%edi
mov    $0x4,%esi
call   10a0 <calloc@plt>
mov    %rax,%rbx
movslq %ebp,%rax
movsd  (%r15,%rax,8),%xmm0
divsd  0xa46(%rip),%xmm0
call   10c0 <floor@plt>
mov    %rax,%rbp
mov    $0xffffffff,%eax
and    %rax,%rbp
je     1689 <execute+0x4e9>
xor    %r13d,%r13d
jmp    160a <execute+0x46a>
cs nopw 0x0(%rax,%rax,1)
nop
divsd  0xa18(%rip),%xmm0
call   10c0 <floor@plt>
mov    %rax,%r12
movsbl %r12b,%edi
call   1040 <putchar@plt>
mov    %r12b,(%rbx,%r13,1)
add    $0x1,%r13
cmp    %r13,%rbp
je     1689 <execute+0x4e9>
movslq (%r14),%rax
movsd  (%r15,%rax,8),%xmm0
test   $0x1,%r13b
jne    15e0 <execute+0x440>
cvttsd2si %xmm0,%eax
movslq %eax,%r12
imul   $0x51eb851f,%r12,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
imul   $0x64,%eax,%eax
sub    %eax,%r12d
mov    %r12d,%edi
call   1040 <putchar@plt>
addl   $0x1,(%r14)
jmp    15f9 <execute+0x459>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
mov    %r15,%rdi
mov    0x8(%rsp),%rsi
mov    %r12,%rdx
mov    %rbx,%rcx
mov    %r13,%r8
mov    %r14,%r9
call   1080 <debug@plt>
jmp    1200 <execute+0x60>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%r13
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%r12
cmpl   $0x1,0x60(%rsp)
jne    1200 <execute+0x60>
jmp    166b <execute+0x4cb>
mov    $0x1,%ebp
jmp    1708 <execute+0x568>
lea    0xb00(%rip),%rbx
lea    0xa28(%rip),%rdi
jmp    16f9 <execute+0x559>
lea    0xad5(%rip),%rbx
lea    0xa18(%rip),%rdi
jmp    16f9 <execute+0x559>
test   %eax,%eax
lea    0xb5e(%rip),%rax
lea    0xb6d(%rip),%rdi
cmovle %rax,%rdi
lea    0x9fb(%rip),%rbx
call   1060 <puts@plt>
xor    %ebp,%ebp
mov    %rbx,%rdi
call   1060 <puts@plt>
mov    %ebp,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ebp
lea    0xac2(%rip),%rbx
jmp    1700 <execute+0x560>

LLVM IR (-O0):
@.str = [51 x i8] c"*** Simpletron execution abnormally terminated ***\00"
@.str.1 = [33 x i8] c"*** Program execution begins ***\00"
@.str.2 = [3 x i8] c"? \00"
@.str.3 = [4 x i8] c"%lf\00"
@.str.4 = [7 x i8] c"%*[^\0A]\00"
@.str.5 = [48 x i8] c"Attenzione, sono consentiti solo numeri interi.\00"
@.str.6 = [36 x i8] c"Risultato dell'elaborazione: %+5lf\0A\00"
@.str.7 = [27 x i8] c"*** Aritmetic overflow ***\00"
@.str.8 = [34 x i8] c"*** Attempt to divide by zero ***\00"
@.str.9 = [40 x i8] c"*** Simpletron execution terminated ***\00"
@.str.10 = [3 x i8] c"%s\00"
@.str.11 = [2 x i8] c"\0A\00"
@.str.12 = [49 x i8] c"Sono consentite solo lettere maiuscole e numeri.\00"
@.str.13 = [5 x i8] c"%79s\00"
@.str.14 = [3 x i8] c"%c\00"
@.str.15 = [1 x i8] zeroinitializer
@.str.16 = [22 x i8] c"*** Loop detected ***\00"
@.str.17 = [50 x i8] c"*** Atempt to use unrecognized operation code ***\00"
define i32 @execute(double* %0, double* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32 %6) {
%8 = alloca i32
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i8*
%20 = alloca i8*
%21 = alloca i64
store double* %0, double** %9
store double* %1, double** %10
store i32* %2, i32** %11
store i32* %3, i32** %12
store i32* %4, i32** %13
store i32* %5, i32** %14
store i32 %6, i32* %15
store i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), i8** %19
%22 = call i32 @puts(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0))
br label %23
23: ; preds = %506, %7
%24 = load i32*, i32** %12
%25 = load i32, i32* %24
%26 = icmp ne i32 %25, -99999
br i1 %26, label %27, label %510
27: ; preds = %23
%28 = load double*, double** %9
%29 = load i32*, i32** %11
%30 = load i32, i32* %29
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %28, i64 %31
%33 = load double, double* %32
%34 = fptosi double %33 to i32
%35 = load i32*, i32** %12
store i32 %34, i32* %35
%36 = load i32*, i32** %12
%37 = load i32, i32* %36
%38 = sdiv i32 %37, 100
%39 = load i32*, i32** %13
store i32 %38, i32* %39
%40 = load i32*, i32** %12
%41 = load i32, i32* %40
%42 = srem i32 %41, 100
%43 = load i32*, i32** %14
store i32 %42, i32* %43
%44 = load i32*, i32** %13
%45 = load i32, i32* %44
%46 = icmp eq i32 %45, 10
br i1 %46, label %47, label %65
47: ; preds = %27
br label %48
48: ; preds = %61, %47
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%50 = load double*, double** %9
%51 = load i32*, i32** %14
%52 = load i32, i32* %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double, double* %50, i64 %53
%55 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %54)
store i32 %55, i32* %16
%56 = icmp eq i32 %55, 0
br i1 %56, label %57, label %60
57: ; preds = %48
%58 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0))
%59 = call i32 @puts(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.5, i64 0, i64 0))
br label %60
60: ; preds = %57, %48
br label %61
61: ; preds = %60
%62 = load i32, i32* %16
%63 = icmp eq i32 %62, 0
br i1 %63, label %48, label %64
64: ; preds = %61
br label %495
65: ; preds = %27
%66 = load i32*, i32** %13
%67 = load i32, i32* %66
%68 = icmp eq i32 %67, 11
br i1 %68, label %69, label %77
69: ; preds = %65
%70 = load double*, double** %9
%71 = load i32*, i32** %14
%72 = load i32, i32* %71
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %70, i64 %73
%75 = load double, double* %74
%76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), double %75)
br label %494
77: ; preds = %65
%78 = load i32*, i32** %13
%79 = load i32, i32* %78
%80 = icmp eq i32 %79, 20
br i1 %80, label %81, label %89
81: ; preds = %77
%82 = load double*, double** %9
%83 = load i32*, i32** %14
%84 = load i32, i32* %83
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %82, i64 %85
%87 = load double, double* %86
%88 = load double*, double** %10
store double %87, double* %88
br label %493
89: ; preds = %77
%90 = load i32*, i32** %13
%91 = load i32, i32* %90
%92 = icmp eq i32 %91, 21
br i1 %92, label %93, label %101
93: ; preds = %89
%94 = load double*, double** %10
%95 = load double, double* %94
%96 = load double*, double** %9
%97 = load i32*, i32** %14
%98 = load i32, i32* %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %96, i64 %99
store double %95, double* %100
br label %492
101: ; preds = %89
%102 = load i32*, i32** %13
%103 = load i32, i32* %102
%104 = icmp eq i32 %103, 30
br i1 %104, label %105, label %127
105: ; preds = %101
%106 = load double*, double** %9
%107 = load i32*, i32** %14
%108 = load i32, i32* %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %106, i64 %109
%111 = load double, double* %110
%112 = load double*, double** %10
%113 = load double, double* %112
%114 = fadd double %113, %111
store double %114, double* %112
%115 = load double*, double** %10
%116 = load double, double* %115
%117 = fcmp ogt double %116, 9.999000e+03
br i1 %117, label %122, label %118
118: ; preds = %105
%119 = load double*, double** %10
%120 = load double, double* %119
%121 = fcmp olt double %120, -9.999000e+03
br i1 %121, label %122, label %126
122: ; preds = %118, %105
%123 = load i8*, i8** %19
%124 = call i32 @puts(i8* %123)
%125 = call i32 @puts(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %8
br label %511
126: ; preds = %118
br label %491
127: ; preds = %101
%128 = load i32*, i32** %13
%129 = load i32, i32* %128
%130 = icmp eq i32 %129, 31
br i1 %130, label %131, label %149
131: ; preds = %127
%132 = load double*, double** %9
%133 = load i32*, i32** %14
%134 = load i32, i32* %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %132, i64 %135
%137 = load double, double* %136
%138 = load double*, double** %10
%139 = load double, double* %138
%140 = fsub double %139, %137
store double %140, double* %138
%141 = load double*, double** %10
%142 = load double, double* %141
%143 = fcmp olt double %142, -9.999000e+03
br i1 %143, label %144, label %148
144: ; preds = %131
%145 = load i8*, i8** %19
%146 = call i32 @puts(i8* %145)
%147 = call i32 @puts(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %8
br label %511
148: ; preds = %131
br label %490
149: ; preds = %127
%150 = load i32*, i32** %13
%151 = load i32, i32* %150
%152 = icmp eq i32 %151, 32
br i1 %152, label %153, label %180
153: ; preds = %149
%154 = load double*, double** %9
%155 = load i32*, i32** %14
%156 = load i32, i32* %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %154, i64 %157
%159 = load double, double* %158
%160 = fcmp oeq double %159, 0.000000e+00
br i1 %160, label %165, label %161
161: ; preds = %153
%162 = load double*, double** %10
%163 = load double, double* %162
%164 = fcmp oeq double %163, 0.000000e+00
br i1 %164, label %165, label %169
165: ; preds = %161, %153
%166 = load i8*, i8** %19
%167 = call i32 @puts(i8* %166)
%168 = call i32 @puts(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %8
br label %511
169: ; preds = %161
%170 = load double*, double** %9
%171 = load i32*, i32** %14
%172 = load i32, i32* %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %170, i64 %173
%175 = load double, double* %174
%176 = load double*, double** %10
%177 = load double, double* %176
%178 = fdiv double %177, %175
store double %178, double* %176
br label %179
179: ; preds = %169
br label %489
180: ; preds = %149
%181 = load i32*, i32** %13
%182 = load i32, i32* %181
%183 = icmp eq i32 %182, 52
br i1 %183, label %184, label %220
184: ; preds = %180
%185 = load double*, double** %9
%186 = load i32*, i32** %14
%187 = load i32, i32* %186
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %185, i64 %188
%190 = load double, double* %189
%191 = fcmp oeq double %190, 0.000000e+00
br i1 %191, label %196, label %192
192: ; preds = %184
%193 = load double*, double** %10
%194 = load double, double* %193
%195 = fcmp oeq double %194, 0.000000e+00
br i1 %195, label %196, label %200
196: ; preds = %192, %184
%197 = load i8*, i8** %19
%198 = call i32 @puts(i8* %197)
%199 = call i32 @puts(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %8
br label %511
200: ; preds = %192
%201 = load double*, double** %10
%202 = load double, double* %201
%203 = fmul double %202, 1.000000e+03
%204 = fptoui double %203 to i32
store i32 %204, i32* %17
%205 = load double*, double** %9
%206 = load i32*, i32** %14
%207 = load i32, i32* %206
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds double, double* %205, i64 %208
%210 = load double, double* %209
%211 = fmul double %210, 1.000000e+03
%212 = fptoui double %211 to i32
store i32 %212, i32* %18
%213 = load i32, i32* %17
%214 = load i32, i32* %18
%215 = urem i32 %213, %214
%216 = udiv i32 %215, 1000
%217 = uitofp i32 %216 to double
%218 = load double*, double** %10
store double %217, double* %218
br label %219
219: ; preds = %200
br label %488
220: ; preds = %180
%221 = load i32*, i32** %13
%222 = load i32, i32* %221
%223 = icmp eq i32 %222, 33
br i1 %223, label %224, label %246
224: ; preds = %220
%225 = load double*, double** %9
%226 = load i32*, i32** %14
%227 = load i32, i32* %226
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds double, double* %225, i64 %228
%230 = load double, double* %229
%231 = load double*, double** %10
%232 = load double, double* %231
%233 = fmul double %232, %230
store double %233, double* %231
%234 = load double*, double** %10
%235 = load double, double* %234
%236 = fcmp ogt double %235, 9.999000e+03
br i1 %236, label %241, label %237
237: ; preds = %224
%238 = load double*, double** %10
%239 = load double, double* %238
%240 = fcmp olt double %239, -9.999000e+03
br i1 %240, label %241, label %245
241: ; preds = %237, %224
%242 = load i8*, i8** %19
%243 = call i32 @puts(i8* %242)
%244 = call i32 @puts(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %8
br label %511
245: ; preds = %237
br label %487
246: ; preds = %220
%247 = load i32*, i32** %13
%248 = load i32, i32* %247
%249 = icmp eq i32 %248, 53
br i1 %249, label %250, label %268
250: ; preds = %246
%251 = load double*, double** %10
%252 = load double, double* %251
%253 = load double*, double** %10
%254 = load double, double* %253
%255 = fmul double %254, %252
store double %255, double* %253
%256 = load double*, double** %10
%257 = load double, double* %256
%258 = fcmp ogt double %257, 9.999000e+03
br i1 %258, label %263, label %259
259: ; preds = %250
%260 = load double*, double** %10
%261 = load double, double* %260
%262 = fcmp olt double %261, -9.999000e+03
br i1 %262, label %263, label %267
263: ; preds = %259, %250
%264 = load i8*, i8** %19
%265 = call i32 @puts(i8* %264)
%266 = call i32 @puts(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %8
br label %511
267: ; preds = %259
br label %486
268: ; preds = %246
%269 = load i32*, i32** %13
%270 = load i32, i32* %269
%271 = icmp eq i32 %270, 40
br i1 %271, label %272, label %277
272: ; preds = %268
%273 = load i32*, i32** %14
%274 = load i32, i32* %273
%275 = sub nsw i32 %274, 1
%276 = load i32*, i32** %11
store i32 %275, i32* %276
br label %485
277: ; preds = %268
%278 = load i32*, i32** %13
%279 = load i32, i32* %278
%280 = icmp eq i32 %279, 41
br i1 %280, label %281, label %291
281: ; preds = %277
%282 = load double*, double** %10
%283 = load double, double* %282
%284 = fcmp olt double %283, 0.000000e+00
br i1 %284, label %285, label %290
285: ; preds = %281
%286 = load i32*, i32** %14
%287 = load i32, i32* %286
%288 = sub nsw i32 %287, 1
%289 = load i32*, i32** %11
store i32 %288, i32* %289
br label %290
290: ; preds = %285, %281
br label %484
291: ; preds = %277
%292 = load i32*, i32** %13
%293 = load i32, i32* %292
%294 = icmp eq i32 %293, 42
br i1 %294, label %295, label %305
295: ; preds = %291
%296 = load double*, double** %10
%297 = load double, double* %296
%298 = fcmp oeq double %297, 0.000000e+00
br i1 %298, label %299, label %304
299: ; preds = %295
%300 = load i32*, i32** %14
%301 = load i32, i32* %300
%302 = sub nsw i32 %301, 1
%303 = load i32*, i32** %11
store i32 %302, i32* %303
br label %304
304: ; preds = %299, %295
br label %483
305: ; preds = %291
%306 = load i32*, i32** %13
%307 = load i32, i32* %306
%308 = icmp eq i32 %307, 43
br i1 %308, label %309, label %311
309: ; preds = %305
%310 = call i32 @puts(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.9, i64 0, i64 0))
store i32 1, i32* %8
br label %511
311: ; preds = %305
%312 = load i32*, i32** %13
%313 = load i32, i32* %312
%314 = icmp eq i32 %313, 60
br i1 %314, label %315, label %317
315: ; preds = %311
%316 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
br label %481
317: ; preds = %311
%318 = load i32*, i32** %13
%319 = load i32, i32* %318
%320 = icmp eq i32 %319, 61
br i1 %320, label %321, label %403
321: ; preds = %317
%322 = call i8* @calloc(i32 80, i32 1)
store i8* %322, i8** %20
%323 = call i32 @puts(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.12, i64 0, i64 0))
%324 = load i8*, i8** %20
%325 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i8* %324)
%326 = load i8*, i8** %20
%327 = call i32 @strlen(i8* %326)
store i32 %327, i32* %17
%328 = load i32, i32* %17
%329 = mul i32 %328, 100
%330 = uitofp i32 %329 to double
%331 = load double*, double** %9
%332 = load i32*, i32** %14
%333 = load i32, i32* %332
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %331, i64 %334
store double %330, double* %335
store i64 0, i64* %21
br label %336
336: ; preds = %341, %321
%337 = load i64, i64* %21
%338 = load i32, i32* %17
%339 = zext i32 %338 to i64
%340 = icmp ule i64 %337, %339
br i1 %340, label %341, label %352
341: ; preds = %336
%342 = load i8*, i8** %20
%343 = load i64, i64* %21
%344 = getelementptr inbounds i8, i8* %342, i64 %343
%345 = load i8, i8* %344
%346 = call signext i8 @toupper(i8 signext %345)
%347 = load i8*, i8** %20
%348 = load i64, i64* %21
%349 = getelementptr inbounds i8, i8* %347, i64 %348
store i8 %346, i8* %349
%350 = load i64, i64* %21
%351 = add i64 %350, 1
store i64 %351, i64* %21
br label %336
352: ; preds = %336
store i64 0, i64* %21
br label %353
353: ; preds = %397, %352
%354 = load i64, i64* %21
%355 = load i32, i32* %17
%356 = zext i32 %355 to i64
%357 = icmp ule i64 %354, %356
br i1 %357, label %358, label %400
358: ; preds = %353
%359 = load i64, i64* %21
%360 = urem i64 %359, 2
%361 = icmp eq i64 %360, 0
br i1 %361, label %362, label %384
362: ; preds = %358
%363 = load i8*, i8** %20
%364 = load i64, i64* %21
%365 = getelementptr inbounds i8, i8* %363, i64 %364
%366 = load i8, i8* %365
%367 = sext i8 %366 to i32
%368 = sitofp i32 %367 to double
%369 = load double*, double** %9
%370 = load i32*, i32** %14
%371 = load i32, i32* %370
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double, double* %369, i64 %372
%374 = load double, double* %373
%375 = fadd double %368, %374
%376 = load double*, double** %9
%377 = load i32*, i32** %14
%378 = load i32, i32* %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %376, i64 %379
store double %375, double* %380
%381 = load i32*, i32** %14
%382 = load i32, i32* %381
%383 = add nsw i32 %382, 1
store i32 %383, i32* %381
br label %397
384: ; preds = %358
%385 = load i8*, i8** %20
%386 = load i64, i64* %21
%387 = getelementptr inbounds i8, i8* %385, i64 %386
%388 = load i8, i8* %387
%389 = sext i8 %388 to i32
%390 = mul nsw i32 %389, 100
%391 = sitofp i32 %390 to double
%392 = load double*, double** %9
%393 = load i32*, i32** %14
%394 = load i32, i32* %393
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %392, i64 %395
store double %391, double* %396
br label %397
397: ; preds = %384, %362
%398 = load i64, i64* %21
%399 = add i64 %398, 1
store i64 %399, i64* %21
br label %353
400: ; preds = %353
%401 = load i8*, i8** %20
%402 = call i32 @free(i8* %401)
br label %480
403: ; preds = %317
%404 = load i32*, i32** %13
%405 = load i32, i32* %404
%406 = icmp eq i32 %405, 62
br i1 %406, label %407, label %467
407: ; preds = %403
%408 = call i8* @calloc(i32 80, i32 4)
store i8* %408, i8** %20
%409 = load double*, double** %9
%410 = load i32*, i32** %14
%411 = load i32, i32* %410
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds double, double* %409, i64 %412
%414 = load double, double* %413
%415 = fdiv double %414, 1.000000e+02
%416 = call i8* @floor(double %415)
%417 = ptrtoint i8* %416 to i32
store i32 %417, i32* %17
store i64 0, i64* %21
br label %418
418: ; preds = %460, %407
%419 = load i64, i64* %21
%420 = load i32, i32* %17
%421 = zext i32 %420 to i64
%422 = icmp ult i64 %419, %421
br i1 %422, label %423, label %463
423: ; preds = %418
%424 = load i64, i64* %21
%425 = urem i64 %424, 2
%426 = icmp eq i64 %425, 0
br i1 %426, label %427, label %445
427: ; preds = %423
%428 = load double*, double** %9
%429 = load i32*, i32** %14
%430 = load i32, i32* %429
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds double, double* %428, i64 %431
%433 = load double, double* %432
%434 = fptosi double %433 to i32
%435 = srem i32 %434, 100
%436 = trunc i32 %435 to i8
%437 = load i8*, i8** %20
%438 = load i64, i64* %21
%439 = getelementptr inbounds i8, i8* %437, i64 %438
store i8 %436, i8* %439
%440 = sext i8 %436 to i32
%441 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32 %440)
%442 = load i32*, i32** %14
%443 = load i32, i32* %442
%444 = add nsw i32 %443, 1
store i32 %444, i32* %442
br label %460
445: ; preds = %423
%446 = load double*, double** %9
%447 = load i32*, i32** %14
%448 = load i32, i32* %447
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double, double* %446, i64 %449
%451 = load double, double* %450
%452 = fdiv double %451, 1.000000e+02
%453 = call i8* @floor(double %452)
%454 = ptrtoint i8* %453 to i8
%455 = load i8*, i8** %20
%456 = load i64, i64* %21
%457 = getelementptr inbounds i8, i8* %455, i64 %456
store i8 %454, i8* %457
%458 = sext i8 %454 to i32
%459 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32 %458)
br label %460
460: ; preds = %445, %427
%461 = load i64, i64* %21
%462 = add i64 %461, 1
store i64 %462, i64* %21
br label %418
463: ; preds = %418
%464 = call i32 @puts(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.15, i64 0, i64 0))
%465 = load i8*, i8** %20
%466 = call i32 @free(i8* %465)
br label %479
467: ; preds = %403
%468 = load i32*, i32** %13
%469 = load i32, i32* %468
%470 = icmp sle i32 %469, 0
br i1 %470, label %471, label %475
471: ; preds = %467
%472 = call i32 @puts(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.16, i64 0, i64 0))
%473 = load i8*, i8** %19
%474 = call i32 @puts(i8* %473)
store i32 0, i32* %8
br label %511
475: ; preds = %467
%476 = call i32 @puts(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.17, i64 0, i64 0))
%477 = load i8*, i8** %19
%478 = call i32 @puts(i8* %477)
store i32 0, i32* %8
br label %511
479: ; preds = %463
br label %480
480: ; preds = %479, %400
br label %481
481: ; preds = %480, %315
br label %482
482: ; preds = %481
br label %483
483: ; preds = %482, %304
br label %484
484: ; preds = %483, %290
br label %485
485: ; preds = %484, %272
br label %486
486: ; preds = %485, %267
br label %487
487: ; preds = %486, %245
br label %488
488: ; preds = %487, %219
br label %489
489: ; preds = %488, %179
br label %490
490: ; preds = %489, %148
br label %491
491: ; preds = %490, %126
br label %492
492: ; preds = %491, %93
br label %493
493: ; preds = %492, %81
br label %494
494: ; preds = %493, %69
br label %495
495: ; preds = %494, %64
%496 = load i32, i32* %15
%497 = icmp eq i32 %496, 1
br i1 %497, label %498, label %506
498: ; preds = %495
%499 = load double*, double** %9
%500 = load double*, double** %10
%501 = load i32*, i32** %11
%502 = load i32*, i32** %12
%503 = load i32*, i32** %13
%504 = load i32*, i32** %14
%505 = call i32 @debug(double* %499, double* %500, i32* %501, i32* %502, i32* %503, i32* %504)
br label %506
506: ; preds = %498, %495
%507 = load i32*, i32** %11
%508 = load i32, i32* %507
%509 = add nsw i32 %508, 1
store i32 %509, i32* %507
br label %23
510: ; preds = %23
store i32 1, i32* %8
br label %511
511: ; preds = %510, %475, %471, %309, %263, %241, %196, %165, %144, %122
%512 = load i32, i32* %8
ret i32 %512
}

LLVM IR (-O2):
@.str = [51 x i8] c"*** Simpletron execution abnormally terminated ***\00"
@.str.1 = [33 x i8] c"*** Program execution begins ***\00"
@.str.2 = [3 x i8] c"? \00"
@.str.3 = [4 x i8] c"%lf\00"
@.str.4 = [7 x i8] c"%*[^\0A]\00"
@.str.5 = [48 x i8] c"Attenzione, sono consentiti solo numeri interi.\00"
@.str.6 = [36 x i8] c"Risultato dell'elaborazione: %+5lf\0A\00"
@.str.7 = [27 x i8] c"*** Aritmetic overflow ***\00"
@.str.8 = [34 x i8] c"*** Attempt to divide by zero ***\00"
@.str.9 = [40 x i8] c"*** Simpletron execution terminated ***\00"
@.str.12 = [49 x i8] c"Sono consentite solo lettere maiuscole e numeri.\00"
@.str.13 = [5 x i8] c"%79s\00"
@.str.16 = [22 x i8] c"*** Loop detected ***\00"
@.str.17 = [50 x i8] c"*** Atempt to use unrecognized operation code ***\00"
define i32 @execute(double* %0, double* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32 %6) {
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0))
%9 = load i32, i32* %3
%10 = icmp eq i32 %9, -99999
br i1 %10, label %225, label %11
11: ; preds = %7
%12 = icmp eq i32 %6, 1
%13 = load i32, i32* %2
br label %14
14: ; preds = %11, %212
%15 = phi i32 [ %13, %11 ], [ %214, %212 ]
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds double, double* %0, i64 %16
%18 = load double, double* %17
%19 = fptosi double %18 to i32
store i32 %19, i32* %3
%20 = sdiv i32 %19, 100
store i32 %20, i32* %4
%21 = load i32, i32* %3
%22 = srem i32 %21, 100
store i32 %22, i32* %5
%23 = load i32, i32* %4
switch i32 %23, label %206 [
i32 10, label %24
i32 11, label %40
i32 20, label %45
i32 21, label %49
i32 30, label %53
i32 31, label %62
i32 32, label %69
i32 52, label %79
i32 33, label %95
i32 53, label %104
i32 40, label %108
i32 41, label %110
i32 42, label %115
i32 43, label %221
i32 60, label %120
i32 61, label %122
i32 62, label %166
]
24: ; preds = %14
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%26 = load i32, i32* %5
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds double, double* %0, i64 %27
%29 = tail call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %28)
%30 = icmp eq i32 %29, 0
br i1 %30, label %31, label %209
31: ; preds = %24, %31
%32 = tail call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0))
%33 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.5, i64 0, i64 0))
%34 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%35 = load i32, i32* %5
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %0, i64 %36
%38 = tail call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %37)
%39 = icmp eq i32 %38, 0
br i1 %39, label %31, label %209
40: ; preds = %14
%41 = sext i32 %22 to i64
%42 = getelementptr inbounds double, double* %0, i64 %41
%43 = load double, double* %42
%44 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), double %43)
br label %209
45: ; preds = %14
%46 = sext i32 %22 to i64
%47 = getelementptr inbounds double, double* %0, i64 %46
%48 = load double, double* %47
store double %48, double* %1
br label %209
49: ; preds = %14
%50 = load double, double* %1
%51 = sext i32 %22 to i64
%52 = getelementptr inbounds double, double* %0, i64 %51
store double %50, double* %52
br label %209
53: ; preds = %14
%54 = sext i32 %22 to i64
%55 = getelementptr inbounds double, double* %0, i64 %54
%56 = load double, double* %55
%57 = load double, double* %1
%58 = fadd double %56, %57
store double %58, double* %1
%59 = fcmp ogt double %58, 9.999000e+03
%60 = fcmp olt double %58, -9.999000e+03
%61 = or i1 %59, %60
br i1 %61, label %217, label %209
62: ; preds = %14
%63 = sext i32 %22 to i64
%64 = getelementptr inbounds double, double* %0, i64 %63
%65 = load double, double* %64
%66 = load double, double* %1
%67 = fsub double %66, %65
store double %67, double* %1
%68 = fcmp olt double %67, -9.999000e+03
br i1 %68, label %217, label %209
69: ; preds = %14
%70 = sext i32 %22 to i64
%71 = getelementptr inbounds double, double* %0, i64 %70
%72 = load double, double* %71
%73 = fcmp oeq double %72, 0.000000e+00
br i1 %73, label %217, label %74
74: ; preds = %69
%75 = load double, double* %1
%76 = fcmp oeq double %75, 0.000000e+00
br i1 %76, label %217, label %77
77: ; preds = %74
%78 = fdiv double %75, %72
store double %78, double* %1
br label %209
79: ; preds = %14
%80 = sext i32 %22 to i64
%81 = getelementptr inbounds double, double* %0, i64 %80
%82 = load double, double* %81
%83 = fcmp oeq double %82, 0.000000e+00
br i1 %83, label %217, label %84
84: ; preds = %79
%85 = load double, double* %1
%86 = fcmp oeq double %85, 0.000000e+00
br i1 %86, label %217, label %87
87: ; preds = %84
%88 = fmul double %85, 1.000000e+03
%89 = fptoui double %88 to i32
%90 = fmul double %82, 1.000000e+03
%91 = fptoui double %90 to i32
%92 = urem i32 %89, %91
%93 = udiv i32 %92, 1000
%94 = uitofp i32 %93 to double
store double %94, double* %1
br label %209
95: ; preds = %14
%96 = sext i32 %22 to i64
%97 = getelementptr inbounds double, double* %0, i64 %96
%98 = load double, double* %97
%99 = load double, double* %1
%100 = fmul double %98, %99
store double %100, double* %1
%101 = fcmp ogt double %100, 9.999000e+03
%102 = fcmp olt double %100, -9.999000e+03
%103 = or i1 %101, %102
br i1 %103, label %217, label %209
104: ; preds = %14
%105 = load double, double* %1
%106 = fmul double %105, %105
store double %106, double* %1
%107 = fcmp ogt double %106, 9.999000e+03
br i1 %107, label %217, label %209
108: ; preds = %14
%109 = add nsw i32 %22, -1
store i32 %109, i32* %2
br label %209
110: ; preds = %14
%111 = load double, double* %1
%112 = fcmp olt double %111, 0.000000e+00
br i1 %112, label %113, label %209
113: ; preds = %110
%114 = add nsw i32 %22, -1
store i32 %114, i32* %2
br label %209
115: ; preds = %14
%116 = load double, double* %1
%117 = fcmp oeq double %116, 0.000000e+00
br i1 %117, label %118, label %209
118: ; preds = %115
%119 = add nsw i32 %22, -1
store i32 %119, i32* %2
br label %209
120: ; preds = %14
%121 = tail call i32 @putchar(i32 10)
br label %209
122: ; preds = %14
%123 = tail call dereferenceable_or_null(80) i8* @calloc(i32 80, i32 1)
%124 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.12, i64 0, i64 0))
%125 = tail call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i8* %123)
%126 = tail call i32 @strlen(i8* %123)
%127 = mul i32 %126, 100
%128 = uitofp i32 %127 to double
%129 = load i32, i32* %5
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds double, double* %0, i64 %130
store double %128, double* %131
%132 = zext i32 %126 to i64
br label %133
133: ; preds = %122, %133
%134 = phi i64 [ 0, %122 ], [ %138, %133 ]
%135 = getelementptr inbounds i8, i8* %123, i64 %134
%136 = load i8, i8* %135
%137 = tail call signext i8 @toupper(i8 signext %136)
store i8 %137, i8* %135
%138 = add nuw nsw i64 %134, 1
%139 = icmp eq i64 %134, %132
br i1 %139, label %140, label %133
140: ; preds = %133, %161
%141 = phi i64 [ %162, %161 ], [ 0, %133 ]
%142 = and i64 %141, 1
%143 = icmp eq i64 %142, 0
%144 = getelementptr inbounds i8, i8* %123, i64 %141
%145 = load i8, i8* %144
br i1 %143, label %146, label %154
146: ; preds = %140
%147 = sitofp i8 %145 to double
%148 = load i32, i32* %5
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds double, double* %0, i64 %149
%151 = load double, double* %150
%152 = fadd double %151, %147
store double %152, double* %150
%153 = add nsw i32 %148, 1
store i32 %153, i32* %5
br label %161
154: ; preds = %140
%155 = sext i8 %145 to i32
%156 = mul nsw i32 %155, 100
%157 = sitofp i32 %156 to double
%158 = load i32, i32* %5
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %0, i64 %159
store double %157, double* %160
br label %161
161: ; preds = %154, %146
%162 = add nuw nsw i64 %141, 1
%163 = icmp eq i64 %141, %132
br i1 %163, label %164, label %140
164: ; preds = %161
%165 = tail call i32 @free(i8* %123)
br label %209
166: ; preds = %14
%167 = tail call dereferenceable_or_null(320) i8* @calloc(i32 80, i32 4)
%168 = sext i32 %22 to i64
%169 = getelementptr inbounds double, double* %0, i64 %168
%170 = load double, double* %169
%171 = fdiv double %170, 1.000000e+02
%172 = tail call i8* @floor(double %171)
%173 = ptrtoint i8* %172 to i64
%174 = and i64 %173, 4294967295
%175 = icmp eq i64 %174, 0
br i1 %175, label %203, label %176
176: ; preds = %166, %198
%177 = phi i64 [ %201, %198 ], [ 0, %166 ]
%178 = and i64 %177, 1
%179 = icmp eq i64 %178, 0
%180 = load i32, i32* %5
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %0, i64 %181
%183 = load double, double* %182
br i1 %179, label %184, label %191
184: ; preds = %176
%185 = fptosi double %183 to i32
%186 = srem i32 %185, 100
%187 = trunc i32 %186 to i8
%188 = tail call i32 @putchar(i32 %186)
%189 = load i32, i32* %5
%190 = add nsw i32 %189, 1
store i32 %190, i32* %5
br label %198
191: ; preds = %176
%192 = fdiv double %183, 1.000000e+02
%193 = tail call i8* @floor(double %192)
%194 = ptrtoint i8* %193 to i64
%195 = trunc i64 %194 to i8
%196 = sext i8 %195 to i32
%197 = tail call i32 @putchar(i32 %196)
br label %198
198: ; preds = %191, %184
%199 = phi i8 [ %187, %184 ], [ %195, %191 ]
%200 = getelementptr inbounds i8, i8* %167, i64 %177
store i8 %199, i8* %200
%201 = add nuw nsw i64 %177, 1
%202 = icmp eq i64 %201, %174
br i1 %202, label %203, label %176
203: ; preds = %198, %166
%204 = tail call i32 @putchar(i32 10)
%205 = tail call i32 @free(i8* %167)
br label %209
206: ; preds = %14
%207 = icmp slt i32 %23, 1
%208 = select i1 %207, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.17, i64 0, i64 0)
br label %217
209: ; preds = %31, %24, %104, %95, %53, %40, %49, %62, %87, %113, %110, %164, %203, %120, %115, %118, %108, %77, %45
br i1 %12, label %210, label %212
210: ; preds = %209
%211 = tail call i32 @debug(double* %0, double* %1, i32* %2, i32* %3, i32* %4, i32* %5)
br label %212
212: ; preds = %210, %209
%213 = load i32, i32* %2
%214 = add nsw i32 %213, 1
store i32 %214, i32* %2
%215 = load i32, i32* %3
%216 = icmp eq i32 %215, -99999
br i1 %216, label %225, label %14
217: ; preds = %104, %95, %79, %84, %69, %74, %62, %53, %206
%218 = phi i8* [ %208, %206 ], [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %53 ], [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %62 ], [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %74 ], [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %69 ], [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %84 ], [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %79 ], [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %95 ], [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %104 ]
%219 = phi i8* [ getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), %206 ], [ getelementptr inbounds ([27 x i8], [27 x i8]* @.str.7, i64 0, i64 0), %104 ], [ getelementptr inbounds ([27 x i8], [27 x i8]* @.str.7, i64 0, i64 0), %95 ], [ getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), %79 ], [ getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), %84 ], [ getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), %69 ], [ getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), %74 ], [ getelementptr inbounds ([27 x i8], [27 x i8]* @.str.7, i64 0, i64 0), %62 ], [ getelementptr inbounds ([27 x i8], [27 x i8]* @.str.7, i64 0, i64 0), %53 ]
%220 = tail call i32 @puts(i8* dereferenceable(1) %218)
br label %221
221: ; preds = %14, %217
%222 = phi i8* [ %219, %217 ], [ getelementptr inbounds ([40 x i8], [40 x i8]* @.str.9, i64 0, i64 0), %14 ]
%223 = phi i32 [ 0, %217 ], [ 1, %14 ]
%224 = tail call i32 @puts(i8* dereferenceable(1) %222)
br label %225
225: ; preds = %212, %221, %7
%226 = phi i32 [ 1, %7 ], [ %223, %221 ], [ 1, %212 ]
ret i32 %226
}