#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*/ FILE;

/* Variables and functions */
char *calloc(int, int);
int /*<<< orphan*/ debug(double *, double *, int *, int *, int *, int *);
int /*<<< orphan*/ debugDump(double *, double *, int *, int *, int *, int *,
                             int);
void *floor(double);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
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) {
  FILE *risultatiPtr;
  unsigned int esitoScanf;
  unsigned int buffer;
  unsigned int buffer2;
  char *violation = "*** Simpletron execution abnormally terminated ***";
  char *stringa;
  size_t i;
  puts("*** Program execution begins ***");
  if ((risultatiPtr = fopen("RISULTATI.txt", "w")) == NULL) {
    puts("Impossibile creare file di testo con risultati");
  }
  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]);
      fprintf(risultatiPtr, "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 ***");
      fprintf(risultatiPtr, "%s", "*** Simpletron execution terminated ***");
      return 1;
    } else if (*operationCodePtr == 60) {
      printf("%s\n", "");
      fprintf(risultatiPtr, "%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)));
          fprintf(risultatiPtr, "%c",
                  stringa[i] = floor((memoryPtr[*operandPtr] / 100)));
        }
        i++;
      }
      puts("");
      fprintf(risultatiPtr, "%s\n", "");
      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);
      debugDump(memoryPtr, accumulatorPtr, instructionCounterPtr,
                instructionRegisterPtr, operationCodePtr, operandPtr,
                debugMode);
    }
    ++(*instructionCounterPtr);
  }
  return 1;
}


x86 assembly (clang, -O0):
<execute>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%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    0xe33(%rip),%rax
mov    %rax,-0x58(%rbp)
lea    0xe5b(%rip),%rdi
call   1050 <puts@plt>
lea    0xe70(%rip),%rdi
lea    0xe77(%rip),%rsi
call   10d0 <fopen@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jne    122a <execute+0x6a>
lea    0xe5f(%rip),%rdi
call   1050 <puts@plt>
jmp    122f <execute+0x6f>
mov    -0x28(%rbp),%rax
cmpl   $0xfffe7961,(%rax)
je     1bc0 <execute+0xa00>
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    12f9 <execute+0x139>
jmp    1291 <execute+0xd1>
lea    0xe1b(%rip),%rdi
mov    $0x0,%al
call   1090 <printf@plt>
mov    -0x10(%rbp),%rsi
mov    -0x38(%rbp),%rax
movslq (%rax),%rax
shl    $0x3,%rax
add    %rax,%rsi
lea    0xdfe(%rip),%rdi
mov    $0x0,%al
call   10c0 <scanf@plt>
mov    %eax,-0x44(%rbp)
cmp    $0x0,%eax
jne    12e5 <execute+0x125>
lea    0xde8(%rip),%rdi
mov    $0x0,%al
call   10c0 <scanf@plt>
lea    0xde1(%rip),%rdi
call   1050 <puts@plt>
jmp    12ea <execute+0x12a>
cmpl   $0x0,-0x44(%rbp)
je     1291 <execute+0xd1>
jmp    1b66 <execute+0x9a6>
mov    -0x30(%rbp),%rax
cmpl   $0xb,(%rax)
jne    134b <execute+0x18b>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xdd4(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    -0x40(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xdb2(%rip),%rsi
mov    $0x1,%al
call   10b0 <fprintf@plt>
jmp    1b61 <execute+0x9a1>
mov    -0x30(%rbp),%rax
cmpl   $0x14,(%rax)
jne    1375 <execute+0x1b5>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1b5c <execute+0x99c>
mov    -0x30(%rbp),%rax
cmpl   $0x15,(%rax)
jne    139f <execute+0x1df>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b57 <execute+0x997>
mov    -0x30(%rbp),%rax
cmpl   $0x1e,(%rax)
jne    141e <execute+0x25e>
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  0xc30(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     13f8 <execute+0x238>
mov    -0x18(%rbp),%rax
movsd  0xc22(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    1419 <execute+0x259>
mov    -0x58(%rbp),%rdi
call   1050 <puts@plt>
lea    0xd0d(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
jmp    1b52 <execute+0x992>
mov    -0x30(%rbp),%rax
cmpl   $0x1f,(%rax)
jne    1487 <execute+0x2c7>
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  0xbb9(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    1482 <execute+0x2c2>
mov    -0x58(%rbp),%rdi
call   1050 <puts@plt>
lea    0xca4(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
jmp    1b4d <execute+0x98d>
mov    -0x30(%rbp),%rax
cmpl   $0x20,(%rax)
jne    151d <execute+0x35d>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14bc <execute+0x2fc>
jp     14bc <execute+0x2fc>
jmp    14d7 <execute+0x317>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14f8 <execute+0x338>
jp     14f8 <execute+0x338>
mov    -0x58(%rbp),%rdi
call   1050 <puts@plt>
lea    0xc49(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
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    1b48 <execute+0x988>
mov    -0x30(%rbp),%rax
cmpl   $0x34,(%rax)
jne    15ee <execute+0x42e>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1552 <execute+0x392>
jp     1552 <execute+0x392>
jmp    156d <execute+0x3ad>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    158e <execute+0x3ce>
jp     158e <execute+0x3ce>
mov    -0x58(%rbp),%rdi
call   1050 <puts@plt>
lea    0xbb3(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xa7a(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
mov    %eax,-0x48(%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,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x4c(%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    1b43 <execute+0x983>
mov    -0x30(%rbp),%rax
cmpl   $0x21,(%rax)
jne    166d <execute+0x4ad>
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  0x9e1(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1647 <execute+0x487>
mov    -0x18(%rbp),%rax
movsd  0x9d3(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    1668 <execute+0x4a8>
mov    -0x58(%rbp),%rdi
call   1050 <puts@plt>
lea    0xabe(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
jmp    1b3e <execute+0x97e>
mov    -0x30(%rbp),%rax
cmpl   $0x35,(%rax)
jne    16e4 <execute+0x524>
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  0x96a(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     16be <execute+0x4fe>
mov    -0x18(%rbp),%rax
movsd  0x95c(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    16df <execute+0x51f>
mov    -0x58(%rbp),%rdi
call   1050 <puts@plt>
lea    0xa47(%rip),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
jmp    1b39 <execute+0x979>
mov    -0x30(%rbp),%rax
cmpl   $0x28,(%rax)
jne    1705 <execute+0x545>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1b34 <execute+0x974>
mov    -0x30(%rbp),%rax
cmpl   $0x29,(%rax)
jne    1737 <execute+0x577>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1732 <execute+0x572>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1b2f <execute+0x96f>
mov    -0x30(%rbp),%rax
cmpl   $0x2a,(%rax)
jne    1773 <execute+0x5b3>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    176e <execute+0x5ae>
jp     176e <execute+0x5ae>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1b2a <execute+0x96a>
mov    -0x30(%rbp),%rax
cmpl   $0x2b,(%rax)
jne    17b1 <execute+0x5f1>
lea    0x9cb(%rip),%rdi
call   1050 <puts@plt>
mov    -0x40(%rbp),%rdi
lea    0x9e3(%rip),%rsi
lea    0x9b4(%rip),%rdx
mov    $0x0,%al
call   10b0 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
mov    -0x30(%rbp),%rax
cmpl   $0x3c,(%rax)
jne    17f1 <execute+0x631>
lea    0x9b8(%rip),%rdi
lea    0x948(%rip),%rsi
mov    $0x0,%al
call   1090 <printf@plt>
mov    -0x40(%rbp),%rdi
lea    0x99f(%rip),%rsi
lea    0x92f(%rip),%rdx
mov    $0x0,%al
call   10b0 <fprintf@plt>
jmp    1b20 <execute+0x960>
mov    -0x30(%rbp),%rax
cmpl   $0x3d,(%rax)
jne    1949 <execute+0x789>
mov    $0x50,%edi
mov    $0x1,%esi
call   10a0 <calloc@plt>
mov    %rax,-0x60(%rbp)
lea    0x969(%rip),%rdi
call   1050 <puts@plt>
mov    -0x60(%rbp),%rsi
lea    0x98a(%rip),%rdi
xor    %eax,%eax
call   10c0 <scanf@plt>
mov    -0x60(%rbp),%rdi
call   1070 <strlen@plt>
mov    %eax,-0x48(%rbp)
mov    -0x48(%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,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%ecx
cmp    %rcx,%rax
ja     189d <execute+0x6dd>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
mov    %al,%dl
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    185e <execute+0x69e>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%ecx
cmp    %rcx,%rax
ja     193b <execute+0x77b>
mov    -0x68(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    1907 <execute+0x747>
mov    -0x60(%rbp),%rax
mov    -0x68(%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    192a <execute+0x76a>
mov    -0x60(%rbp),%rax
mov    -0x68(%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    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    18a5 <execute+0x6e5>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
jmp    1b1b <execute+0x95b>
mov    -0x30(%rbp),%rax
cmpl   $0x3e,(%rax)
jne    1ac7 <execute+0x907>
mov    $0x50,%edi
mov    $0x4,%esi
call   10a0 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x67f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   10e0 <floor@plt>
mov    %eax,-0x48(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%ecx
cmp    %rcx,%rax
jae    1a94 <execute+0x8d4>
mov    -0x68(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    19fd <execute+0x83d>
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    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%esi
lea    0x7d1(%rip),%rdi
mov    $0x0,%al
call   1090 <printf@plt>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1a83 <execute+0x8c3>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x5eb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   10e0 <floor@plt>
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%esi
lea    0x784(%rip),%rdi
mov    $0x0,%al
call   1090 <printf@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x5a6(%rip),%xmm1
divsd  %xmm1,%xmm0
call   10e0 <floor@plt>
mov    -0x70(%rbp),%rdi
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%edx
lea    0x73b(%rip),%rsi
mov    $0x0,%al
call   10b0 <fprintf@plt>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1995 <execute+0x7d5>
lea    0x679(%rip),%rdi
call   1050 <puts@plt>
mov    -0x40(%rbp),%rdi
lea    0x6d2(%rip),%rsi
lea    0x662(%rip),%rdx
mov    $0x0,%al
call   10b0 <fprintf@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
jmp    1b16 <execute+0x956>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jg     1af5 <execute+0x935>
lea    0x6df(%rip),%rdi
call   1050 <puts@plt>
mov    -0x58(%rbp),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
lea    0x6d4(%rip),%rdi
call   1050 <puts@plt>
mov    -0x58(%rbp),%rdi
call   1050 <puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    1bc7 <execute+0xa07>
jmp    1b1b <execute+0x95b>
jmp    1b20 <execute+0x960>
jmp    1b25 <execute+0x965>
jmp    1b2a <execute+0x96a>
jmp    1b2f <execute+0x96f>
jmp    1b34 <execute+0x974>
jmp    1b39 <execute+0x979>
jmp    1b3e <execute+0x97e>
jmp    1b43 <execute+0x983>
jmp    1b48 <execute+0x988>
jmp    1b4d <execute+0x98d>
jmp    1b52 <execute+0x992>
jmp    1b57 <execute+0x997>
jmp    1b5c <execute+0x99c>
jmp    1b61 <execute+0x9a1>
jmp    1b66 <execute+0x9a6>
cmpl   $0x1,0x10(%rbp)
jne    1bb0 <execute+0x9f0>
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   1080 <debug@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%eax
mov    %eax,(%rsp)
call   1060 <debugDump@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    122f <execute+0x6f>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%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,%r12
mov    %r8,%r13
mov    %rcx,%rbp
mov    %rdx,%r14
mov    %rsi,0x8(%rsp)
mov    %rdi,%r15
lea    0xf0e(%rip),%rdi
call   1060 <puts@plt>
lea    0xf23(%rip),%rdi
lea    0xf2a(%rip),%rsi
call   10f0 <fopen@plt>
mov    %rax,0x10(%rsp)
test   %rax,%rax
jne    1247 <execute+0x57>
lea    0xf16(%rip),%rdi
call   1060 <puts@plt>
mov    $0x1,%eax
cmpl   $0xfffe7961,0x0(%rbp)
je     17c8 <execute+0x5d8>
mov    (%r14),%eax
xorpd  %xmm2,%xmm2
mov    %rbp,0x20(%rsp)
mov    %r14,0x18(%rsp)
jmp    128a <execute+0x9a>
nopl   0x0(%rax)
mov    (%r14),%eax
add    $0x1,%eax
mov    %eax,(%r14)
cmpl   $0xfffe7961,0x0(%rbp)
xorpd  %xmm2,%xmm2
je     17a7 <execute+0x5b7>
cltq
cvttsd2si (%r15,%rax,8),%eax
mov    %eax,0x0(%rbp)
cltq
imul   $0x51eb851f,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
mov    %eax,0x0(%r13)
movslq 0x0(%rbp),%rbx
imul   $0x51eb851f,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
imul   $0x64,%eax,%eax
sub    %eax,%ebx
mov    %ebx,(%r12)
mov    0x0(%r13),%eax
lea    -0xa(%rax),%ecx
cmp    $0x34,%ecx
ja     1774 <execute+0x584>
lea    0xd39(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
lea    0xe90(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
movslq (%r12),%rax
lea    (%r15,%rax,8),%rsi
lea    0xe7d(%rip),%rdi
xor    %eax,%eax
call   10e0 <scanf@plt>
test   %eax,%eax
jne    1700 <execute+0x510>
lea    0xe6b(%rip),%rdi
xor    %eax,%eax
call   10e0 <scanf@plt>
lea    0xe64(%rip),%rdi
call   1060 <puts@plt>
jmp    12f0 <execute+0x100>
movslq %ebx,%rax
movsd  (%r15,%rax,8),%xmm0
lea    0xe7d(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movslq (%r12),%rax
movsd  (%r15,%rax,8),%xmm0
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x1,%al
call   10d0 <fprintf@plt>
jmp    1700 <execute+0x510>
movslq %ebx,%rax
movsd  (%r15,%rax,8),%xmm0
mov    0x8(%rsp),%rax
movsd  %xmm0,(%rax)
jmp    1700 <execute+0x510>
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm0
movslq %ebx,%rax
movsd  %xmm0,(%r15,%rax,8)
jmp    1700 <execute+0x510>
movslq %ebx,%rax
movsd  (%r15,%rax,8),%xmm0
mov    0x8(%rsp),%rax
addsd  (%rax),%xmm0
jmp    1413 <execute+0x223>
movslq %ebx,%rax
mov    0x8(%rsp),%rcx
movsd  (%rcx),%xmm0
subsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rcx)
jmp    1425 <execute+0x235>
movslq %ebx,%rax
movsd  (%r15,%rax,8),%xmm0
ucomisd %xmm2,%xmm0
mov    0x8(%rsp),%rax
jne    13e4 <execute+0x1f4>
jnp    174a <execute+0x55a>
movsd  (%rax),%xmm1
ucomisd %xmm2,%xmm1
jne    13f4 <execute+0x204>
jnp    174a <execute+0x55a>
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
jmp    1700 <execute+0x510>
movslq %ebx,%rax
movsd  (%r15,%rax,8),%xmm0
mov    0x8(%rsp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
ucomisd 0xbe9(%rip),%xmm0
ja     175f <execute+0x56f>
movsd  0xbe3(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1700 <execute+0x510>
jmp    175f <execute+0x56f>
mov    0x8(%rsp),%rax
ucomisd (%rax),%xmm2
ja     1465 <execute+0x275>
jmp    1700 <execute+0x510>
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm2,%xmm0
jne    1700 <execute+0x510>
jp     1700 <execute+0x510>
add    $0xffffffff,%ebx
mov    %ebx,(%r14)
jmp    1700 <execute+0x510>
movslq %ebx,%rax
movsd  (%r15,%rax,8),%xmm0
ucomisd %xmm2,%xmm0
mov    0x8(%rsp),%rsi
jne    148a <execute+0x29a>
jnp    174a <execute+0x55a>
movsd  (%rsi),%xmm1
ucomisd %xmm2,%xmm1
jne    149a <execute+0x2aa>
jnp    174a <execute+0x55a>
movsd  0xb76(%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)
jmp    1700 <execute+0x510>
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rax)
ucomisd 0xb1c(%rip),%xmm0
jbe    1700 <execute+0x510>
jmp    175f <execute+0x56f>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x10(%rsp),%rdi
lea    0xd41(%rip),%rsi
lea    0xcd4(%rip),%rdx
xor    %eax,%eax
call   10d0 <fprintf@plt>
jmp    1700 <execute+0x510>
mov    $0x50,%edi
mov    $0x1,%esi
call   10c0 <calloc@plt>
mov    %rax,%rbx
lea    0xd19(%rip),%rdi
call   1060 <puts@plt>
lea    0xd3e(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10e0 <scanf@plt>
mov    %rbx,%rdi
call   1080 <strlen@plt>
imul   $0x64,%eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %rcx,%xmm0
movslq (%r12),%rcx
movsd  %xmm0,(%r15,%rcx,8)
mov    %eax,%r14d
add    $0x1,%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsbl (%rbx,%rbp,1),%edi
call   1050 <toupper@plt>
mov    %al,(%rbx,%rbp,1)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1580 <execute+0x390>
xor    %eax,%eax
jmp    15c1 <execute+0x3d1>
nopl   0x0(%rax)
imul   $0x64,%ecx,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movslq (%r12),%rcx
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%rax
cmp    %rax,%r14
je     16bb <execute+0x4cb>
movsbl (%rbx,%rax,1),%ecx
test   $0x1,%al
jne    15a0 <execute+0x3b0>
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movslq (%r12),%rcx
addsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%ecx
mov    %ecx,(%r12)
jmp    15b4 <execute+0x3c4>
mov    %r13,%rbp
mov    $0x50,%edi
mov    $0x4,%esi
call   10c0 <calloc@plt>
mov    %rax,%r13
movslq %ebx,%rax
movsd  (%r15,%rax,8),%xmm0
divsd  0x9f1(%rip),%xmm0
call   1110 <floor@plt>
mov    %rax,%r14
mov    $0xffffffff,%eax
and    %rax,%r14
je     16c5 <execute+0x4d5>
xor    %ebx,%ebx
jmp    167b <execute+0x48b>
nopl   0x0(%rax)
movsd  0x9c8(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1110 <floor@plt>
movsbl %al,%edi
call   1040 <putchar@plt>
movslq (%r12),%rax
movsd  (%r15,%rax,8),%xmm0
divsd  0x9a5(%rip),%xmm0
call   1110 <floor@plt>
mov    %al,0x0(%r13,%rbx,1)
movsbl %al,%edi
mov    0x10(%rsp),%rsi
call   10b0 <fputc@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
je     16c5 <execute+0x4d5>
movslq (%r12),%rax
movsd  (%r15,%rax,8),%xmm0
test   $0x1,%bl
jne    1630 <execute+0x440>
cvttsd2si %xmm0,%eax
movslq %eax,%rdi
imul   $0x51eb851f,%rdi,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
imul   $0x64,%eax,%eax
sub    %eax,%edi
mov    %dil,0x0(%r13,%rbx,1)
call   1040 <putchar@plt>
addl   $0x1,(%r12)
jmp    1672 <execute+0x482>
mov    %rbx,%rdi
call   1030 <free@plt>
jmp    16f4 <execute+0x504>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x10(%rsp),%rdi
lea    0xb73(%rip),%rsi
lea    0xb06(%rip),%rdx
xor    %eax,%eax
call   10d0 <fprintf@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%r13
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%r14
xchg   %ax,%ax
cmpl   $0x1,0x60(%rsp)
jne    1270 <execute+0x80>
mov    %r15,%rdi
mov    0x8(%rsp),%rbx
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %rbp,%rcx
mov    %r13,%r8
mov    %r12,%r9
call   1090 <debug@plt>
movl   $0x1,(%rsp)
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %rbp,%rcx
mov    %r13,%r8
mov    %r12,%r9
call   1070 <debugDump@plt>
jmp    1270 <execute+0x80>
lea    0x9a3(%rip),%rdi
call   1060 <puts@plt>
lea    0xaa7(%rip),%rdi
jmp    17c1 <execute+0x5d1>
lea    0x98e(%rip),%rdi
call   1060 <puts@plt>
lea    0xa77(%rip),%rdi
jmp    17c1 <execute+0x5d1>
test   %eax,%eax
jle    17ae <execute+0x5be>
lea    0xb1f(%rip),%rdi
jmp    17b5 <execute+0x5c5>
lea    0xa9e(%rip),%rbx
mov    %rbx,%rdi
call   1060 <puts@plt>
mov    $0x27,%esi
mov    $0x1,%edx
mov    %rbx,%rdi
mov    0x10(%rsp),%rcx
call   1100 <fwrite@plt>
mov    $0x1,%eax
jmp    17c8 <execute+0x5d8>
lea    0xad3(%rip),%rdi
call   1060 <puts@plt>
lea    0x933(%rip),%rdi
call   1060 <puts@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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