#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 */
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
int /*<<< orphan*/ system(char *);
int main() {
  int resp;
  printf("\t\t-----------------------------------------------------------------"
         "------------------\n\n");
  printf("\t\tLISTA DOS EXERCICIOS DO DIA 08/11/2017\n\n");
  printf("\t\tESCOLHA UMA DAS OPCOES ABAIXO PARA EXECUTAR O EXERCICIO\n\n");
  printf("\t\t-----------------------------------------------------------------"
         "------------------\n\n");
  printf("\t\tEXERCICIO 1 - CONTAGEM REGRESSIVA\n\n");
  printf("\t\tEXERCICIO 2 - POLEGADA/CENTIMETRO\n\n");
  printf("\t\tEXERCICIO 3 - POTENCIA\n\n");
  printf("\t\tEXERCICIO 4 - FATORIAL (SEM RECURSIVIDADE)\n\n");
  printf("\t\tEXERCICIO 5 - POTENCIA COM SOMA DE IMPARES\n\n");
  printf("\t\tEXERCICIO 6 - CONTA BANCO\n\n");
  printf("\t\tEXERCICIO 7 - TRIANGULAR\n\n");
  printf("\t\tEXERCICIO 8 - MAIOR/MENOR IDADE\n\n");
  printf("\t\tEXERCICIO 9 - CAIXA\n\n");
  printf("\t\tEXERCICIO 10 - SALDO BANCO\n\n");
  printf("\t\t-----------------------------------------------------------------"
         "------------------\n\n\t\t");
  scanf("%i", &resp);
  system("cls");
  switch (resp) {
  case 1: {
    int i, n;
    printf("\t\tDigite um numero qualquer\n\n\t\t");
    scanf("%i", &n);
    system("cls");
    for (i = 0; i <= n; n--) {
      printf("\n %i", n);
    }
    break;
  }
  case 2: {
    float i, cm;
    for (i = 0; i <= 10; i += 0.5) {
      cm = i * 2.54;
      printf("\n\n\t\t%.2f polegada equivale a %.2f centimetros\t\t\n\n", i,
             cm);
    }
    break;
  }
  case 3: {
    int x, n, i;
    int pot = 1;
    printf("\n\n\t\tDigite um numero\n\n\t\t");
    scanf("%i", &x);
    printf("\n\n\t\tDigite um outro numero para ser potencia\n\n\t\t");
    scanf("%i", &n);
    for (i = 1; i <= n; i++) {
      pot *= x;
    }
    printf("\n\n\t\t%i elevado a %i = %i", x, n, pot);
    break;
  }
  case 4: {
    int n, i, fat = 1;
    printf("\t\tDigite o numero para fatorar:\n\n\t\t");
    scanf("%i", &n);
    i = n;
    for (; n >= 1; n--) {
      fat *= n;
    }
    printf("\n\n\t\tO fatorial de %i e = %i\n\n", i, fat);
    break;
  }
  case 5: {
    int n, i, quadrado = 0;
    printf("\t\tDigite um numero natural qualquer\n\n\t\t");
    scanf("%d", &n);
    system("cls");
    for (i = 0; i < n; i++) {
      quadrado += (i * 2) + 1;
    }
    printf("\t\tO quadrado do numero digitado na soma de impares e = %d\n\n",
           quadrado);
    break;
  }
  case 6: {
    int conta, s = 0, i, d, aux;
    printf("\t\tDigite o numero da conta\n\n\t\t");
    scanf("%d", &conta);
    system("cls");
    aux = conta;
    while (conta != 0) {
      i = conta % 10;
      conta /= 10;
      s += i;
    }
    d = s % 10;
    printf("\t\tNumero de conta completo: 00%d-%d\n\n", aux, d);
    break;
  }
  case 7: {
    int n, cont = 0, i, t;
    ;
    printf("\t\tDigite um numero natural qualquer\n\n\t\t");
    scanf("%d", &n);
    system("cls");
    for (i = 1; i <= n; i++) {
      if (n == cont || n == 1) {
        printf("\t\tO NUMERO DIGITADO E TRIANGULAR!\n\n");
        t = 1;
        break;
      } else {
        cont += i;
      }
    }
    if (t != 1) {
      printf("\t\tO NUMERO DIGITADO NAO E TRIANGULAR!\n\n");
    }
    break;
  }
  case 8: {
    int n, maior, menor;
    printf("\t\tDigite a idade da pessoa\n\n\t\t");
    scanf("%d", &n);
    menor = n;
    maior = n;
    do {
      system("cls");
      printf("\t\tDigite a idade da pessoa\n\n\t\t");
      scanf("%d", &n);
      if ((n <= menor) && (n > 0)) {
        menor = n;
      } else if (n >= maior) {
        maior = n;
      }
    } while (n > 0);
    system("cls");
    printf("\n\n\t\tA menor idade digitada foi: %d\n\n\t\t", menor);
    printf("A maior idade digitada foi: %d\n\n\t\t", maior);
    break;
  }
  case 9: {
    float val, total = 0, tLiquido = 0;
    do {
      system("cls");
      printf("\t\tDigite o preco do produto (0 para TOTAL A PAGAR)\n\n\t\t");
      scanf("%f", &val);
      total += val;
    } while (val > 0);
    if (total < 50) {
      tLiquido = total - (total * 0.05);
      printf("\n\n\t\tO cliente deve pagar R$ %.2f\n\n", tLiquido);
    } else if (total <= 100) {
      tLiquido = total - (total * 0.10);
      printf("\n\n\t\tO cliente deve pagar R$ %.2f\n\n", tLiquido);
    } else if (total <= 200) {
      tLiquido = total - (total * 0.15);
      printf("\n\n\t\tO cliente deve pagar R$ %.2f\n\n", tLiquido);
    } else {
      tLiquido = total - (total * 0.20);
      printf("\n\n\t\tO cliente deve pagar R$ %.2f\n\n", tLiquido);
    }
    break;
  }
  case 10: {
    float saldoini, totcred = 0, totdeb = 0, cpmf = 0, saldof = 0, val;
    char op;
    printf("\t\tQual o saldo inicial da conta?\n\n\t\t");
    scanf("%f", &saldoini);
    do {
      system("cls");
      printf("\t\tDigite o codigo da operacao de credito (+) ou debito (-) (0 "
             "PARA VER SALDO)\n\t\t");
      scanf(" %c", &op);
      switch (op) {
      case '+': {
        printf("\n\n\t\tDigite o valor da operacao:\n\n\t\t");
        scanf("%f", &val);
        totcred += val;
        break;
      }
      case '-': {
        printf("\n\n\t\tDigite o valor da operacao:\n\n\t\t");
        scanf("%f", &val);
        totdeb += val;
        break;
      }
      }
    } while (op != '0');
    system("cls");
    cpmf = totdeb * 0.0035;
    saldof = ((saldoini - totdeb) + totcred) - cpmf;
    printf("\n\n\t\tTOTAL DE CREDITOS: R$ %.2f\n\t\t", totcred);
    printf("TOTAL DE DEBITOS: R$ %.2f\n\t\t", totdeb);
    printf("CPFM PAGA: R$ %.2f\n\t\t", cpmf);
    printf("SALDO FINAL: R$ %.2f\n\n\t\t", saldof);
    break;
  }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xf27(%rip),%rdi
mov    %rdi,-0xb0(%rbp)
xor    %eax,%eax
mov    %al,-0xa1(%rbp)
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0xf5e(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0xf77(%rip),%rdi
call   1040 <printf@plt>
mov    -0xb0(%rbp),%rdi
mov    -0xa1(%rbp),%al
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0xf8f(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0xfa3(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0xfb7(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0xfc0(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0xfdd(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0xffa(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0x1006(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0x1011(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0x1023(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0x1029(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0x1036(%rip),%rdi
call   1040 <printf@plt>
mov    -0xa1(%rbp),%al
lea    0x10a4(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1050 <scanf@plt>
lea    0x106e(%rip),%rdi
call   1030 <system@plt>
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xa0(%rbp)
sub    $0x9,%eax
ja     1b26 <main+0x9f6>
mov    -0xa0(%rbp),%rax
lea    0xda7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x1037(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x104b(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
lea    0x1013(%rip),%rdi
call   1030 <system@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1308 <main+0x1d8>
mov    -0x10(%rbp),%esi
lea    0x1015(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    12dd <main+0x1ad>
jmp    1b26 <main+0x9f6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  0xd27(%rip),%xmm0
ucomiss -0x14(%rbp),%xmm0
jb     1388 <main+0x258>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcf0(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xfaf(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcba(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
jmp    1315 <main+0x1e5>
jmp    1b26 <main+0x9f6>
movl   $0x1,-0x28(%rbp)
lea    0xfa4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf61(%rip),%rdi
lea    -0x1c(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
lea    0xf9d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf41(%rip),%rdi
lea    -0x20(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     13ff <main+0x2cf>
mov    -0x1c(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13db <main+0x2ab>
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x28(%rbp),%ecx
lea    0xf7a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1b26 <main+0x9f6>
movl   $0x1,-0x34(%rbp)
lea    0xf79(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xed3(%rip),%rdi
lea    -0x2c(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jl     146a <main+0x33a>
mov    -0x2c(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1448 <main+0x318>
mov    -0x30(%rbp),%esi
mov    -0x34(%rbp),%edx
lea    0xf4f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1b26 <main+0x9f6>
movl   $0x0,-0x40(%rbp)
lea    0xf53(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf6d(%rip),%rdi
lea    -0x38(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
lea    0xe33(%rip),%rdi
call   1030 <system@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    14e6 <main+0x3b6>
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14bd <main+0x38d>
mov    -0x40(%rbp),%esi
lea    0xf1f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1b26 <main+0x9f6>
movl   $0x0,-0x48(%rbp)
lea    0xf41(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xef4(%rip),%rdi
lea    -0x44(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
lea    0xdba(%rip),%rdi
call   1030 <system@plt>
mov    -0x44(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     1569 <main+0x439>
mov    -0x44(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1535 <main+0x405>
mov    -0x48(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x50(%rbp)
mov    -0x54(%rbp),%esi
mov    -0x50(%rbp),%edx
lea    0xee6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1b26 <main+0x9f6>
movl   $0x0,-0x5c(%rbp)
lea    0xe46(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe60(%rip),%rdi
lea    -0x58(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
lea    0xd26(%rip),%rdi
call   1030 <system@plt>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     1622 <main+0x4f2>
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
je     15ec <main+0x4bc>
cmpl   $0x1,-0x58(%rbp)
jne    1606 <main+0x4d6>
lea    0xe9d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x64(%rbp)
jmp    1622 <main+0x4f2>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    1614 <main+0x4e4>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    15ca <main+0x49a>
cmpl   $0x1,-0x64(%rbp)
je     163a <main+0x50a>
lea    0xe81(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1b26 <main+0x9f6>
lea    0xe96(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xdb8(%rip),%rdi
lea    -0x68(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x68(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
lea    0xc72(%rip),%rdi
call   1030 <system@plt>
lea    0xe5e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xd80(%rip),%rdi
lea    -0x68(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x68(%rbp),%eax
cmp    -0x70(%rbp),%eax
jg     16b8 <main+0x588>
cmpl   $0x0,-0x68(%rbp)
jle    16b8 <main+0x588>
mov    -0x68(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    16cf <main+0x59f>
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jl     16ca <main+0x59a>
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    16cf <main+0x59f>
jmp    16d4 <main+0x5a4>
cmpl   $0x0,-0x68(%rbp)
jg     166b <main+0x53b>
lea    0xbff(%rip),%rdi
call   1030 <system@plt>
mov    -0x70(%rbp),%esi
lea    0xe07(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x6c(%rbp),%esi
lea    0xe1d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1b26 <main+0x9f6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
lea    0xbbc(%rip),%rdi
call   1030 <system@plt>
lea    0xe11(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe3a(%rip),%rdi
lea    -0x74(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
movss  -0x74(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x74(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1721 <main+0x5f1>
movss  0x8c3(%rip),%xmm0
ucomiss -0x78(%rbp),%xmm0
jbe    17dd <main+0x6ad>
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x870(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdae(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    1920 <main+0x7f0>
movss  0x857(%rip),%xmm0
ucomiss -0x78(%rbp),%xmm0
jb     184d <main+0x71d>
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x7f8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd3e(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    191b <main+0x7eb>
movss  0x7eb(%rip),%xmm0
ucomiss -0x78(%rbp),%xmm0
jb     18bd <main+0x78d>
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x780(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcce(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    1916 <main+0x7e6>
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x71a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc70(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    191b <main+0x7eb>
jmp    1920 <main+0x7f0>
jmp    1b26 <main+0x9f6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
lea    0xc4a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xc16(%rip),%rdi
lea    -0x80(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
lea    0x96c(%rip),%rdi
call   1030 <system@plt>
lea    0xc43(%rip),%rdi
xor    %eax,%eax
mov    %al,-0xb5(%rbp)
call   1040 <printf@plt>
mov    -0xb5(%rbp),%al
lea    0xc7a(%rip),%rdi
lea    -0x95(%rbp),%rsi
call   1050 <scanf@plt>
movsbl -0x95(%rbp),%eax
mov    %eax,-0xb4(%rbp)
sub    $0x2b,%eax
je     19d9 <main+0x8a9>
jmp    19c5 <main+0x895>
mov    -0xb4(%rbp),%eax
sub    $0x2d,%eax
je     1a19 <main+0x8e9>
jmp    1a54 <main+0x924>
lea    0xc3c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xb8e(%rip),%rdi
lea    -0x94(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
movss  -0x94(%rbp),%xmm0
ff
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
jmp    1a54 <main+0x924>
lea    0xbfc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xb4e(%rip),%rdi
lea    -0x94(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
movss  -0x94(%rbp),%xmm0
ff
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
jmp    1a59 <main+0x929>
movsbl -0x95(%rbp),%eax
cmp    $0x30,%eax
jne    1971 <main+0x841>
lea    0x874(%rip),%rdi
call   1030 <system@plt>
movss  -0x88(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x577(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x80(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
addss  -0x84(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb6f(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  -0x88(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb77(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb7a(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb76(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
lea    0x1540(%rip),%rbx
mov    %rbx,%rdi
call   1030 <puts@plt>
lea    0x14cc(%rip),%rdi
call   1030 <puts@plt>
lea    0x14ea(%rip),%rdi
call   1030 <puts@plt>
mov    %rbx,%rdi
call   1030 <puts@plt>
lea    0x1568(%rip),%rdi
call   1030 <puts@plt>
lea    0x1581(%rip),%rdi
call   1030 <puts@plt>
lea    0x159a(%rip),%rdi
call   1030 <puts@plt>
lea    0x15a8(%rip),%rdi
call   1030 <puts@plt>
lea    0x15ca(%rip),%rdi
call   1030 <puts@plt>
lea    0x15ec(%rip),%rdi
call   1030 <puts@plt>
lea    0x15fd(%rip),%rdi
call   1030 <puts@plt>
lea    0x160d(%rip),%rdi
call   1030 <puts@plt>
lea    0x1624(%rip),%rdi
call   1030 <puts@plt>
lea    0x162f(%rip),%rdi
call   1030 <puts@plt>
lea    0x105c(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x10ce(%rip),%rdi
lea    0x1c(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0x1095(%rip),%rdi
call   1040 <system@plt>
mov    0x1c(%rsp),%eax
add    $0xffffffff,%eax
cmp    $0x9,%eax
ja     1e57 <main+0xd17>
lea    0xff7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x106d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1081(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0x1048(%rip),%rdi
call   1040 <system@plt>
mov    0x4(%rsp),%esi
test   %esi,%esi
js     1e57 <main+0xd17>
lea    0x1054(%rip),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x4(%rsp),%eax
lea    -0x1(%rax),%esi
mov    %esi,0x4(%rsp)
test   %eax,%eax
jg     1290 <main+0x150>
jmp    1e57 <main+0xd17>
lea    0x1026(%rip),%rbx
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd5b(%rip),%xmm0
movsd  0xd5b(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd51(%rip),%xmm0
movsd  0xd51(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd47(%rip),%xmm0
movsd  0xd47(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd3d(%rip),%xmm0
movsd  0xd3d(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd33(%rip),%xmm0
movsd  0xd33(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd29(%rip),%xmm0
movsd  0xd29(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd1f(%rip),%xmm0
movsd  0xd1f(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd15(%rip),%xmm0
movsd  0xd15(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd0b(%rip),%xmm0
movsd  0xd0b(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xd01(%rip),%xmm0
movsd  0xd01(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xcf7(%rip),%xmm0
movsd  0xcf7(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xced(%rip),%xmm0
movsd  0xced(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xce3(%rip),%xmm0
movsd  0xce3(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xcd9(%rip),%xmm0
movsd  0xcd9(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xccf(%rip),%xmm0
movsd  0xccf(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xcc5(%rip),%xmm0
movsd  0xcc5(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xcbb(%rip),%xmm0
movsd  0xcbb(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xcb1(%rip),%xmm0
movsd  0xcb1(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0xca7(%rip),%xmm0
movsd  0xca7(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movq   0xc9d(%rip),%xmm0
movq   0xc9d(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1050 <printf@plt>
jmp    1e57 <main+0xd17>
lea    0xe34(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdf1(%rip),%rbx
lea    0x4(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xe29(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x14(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0x14(%rsp),%edx
mov    0x4(%rsp),%esi
test   %edx,%edx
jle    1a59 <main+0x919>
mov    $0x1,%eax
mov    $0x1,%ecx
cmp    $0x8,%edx
jb     1bfe <main+0xabe>
mov    %edx,%eax
and    $0xfffffff8,%eax
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%ebp
mov    %ebp,%edi
shr    $0x3,%edi
add    $0x1,%edi
mov    %edi,%ecx
and    $0x7,%ecx
pshufd $0xf5,%xmm0,%xmm1
cmp    $0x38,%ebp
jae    1aa2 <main+0x962>
movdqa 0xc36(%rip),%xmm3
movdqa %xmm3,%xmm2
jmp    1b6f <main+0xa2f>
lea    0xdf6(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xd50(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0x4(%rsp),%esi
mov    $0x1,%edx
test   %esi,%esi
jle    1e25 <main+0xce5>
mov    %esi,%eax
cmp    $0x8,%esi
jb     1e10 <main+0xcd0>
mov    %esi,%eax
and    $0xfffffff8,%eax
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm6
paddd  0xbca(%rip),%xmm6
lea    -0x8(%rax),%edi
mov    %edi,%edx
shr    $0x3,%edx
add    $0x1,%edx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%edi
jae    1c2b <main+0xaeb>
movdqa 0xbb9(%rip),%xmm1
movdqa %xmm1,%xmm2
jmp    1d61 <main+0xc21>
lea    0xdbb(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdd3(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xc98(%rip),%rdi
call   1040 <system@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    163c <main+0x4fc>
lea    (%rax,%rax,2),%ecx
lea    -0x1(%rax),%edx
add    $0xfffffffe,%eax
imul   %edx,%eax
and    $0xfffffffe,%eax
lea    (%rax,%rcx,1),%ebx
add    $0xfffffffe,%ebx
lea    0xd9a(%rip),%rdi
mov    %ebx,%esi
jmp    17ee <main+0x6ae>
lea    0xdc8(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xd79(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xc3e(%rip),%rdi
call   1040 <system@plt>
mov    0x4(%rsp),%esi
test   %esi,%esi
je     16dd <main+0x59d>
xor    %eax,%eax
mov    %esi,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ecx,%rdx
imul   $0x66666667,%rdx,%rcx
mov    %rcx,%rdi
shr    $0x3f,%rdi
sar    $0x22,%rcx
add    %edi,%ecx
lea    (%rcx,%rcx,1),%edi
lea    (%rdi,%rdi,4),%edi
mov    %edx,%ebp
sub    %edi,%ebp
add    %ebp,%eax
add    $0x9,%edx
cmp    $0x12,%edx
ja     1690 <main+0x550>
mov    %ecx,0x4(%rsp)
movslq %eax,%rbx
imul   $0x66666667,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rax
add    %ecx,%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%ebx
lea    0xd54(%rip),%rdi
mov    %ebx,%edx
jmp    1e2c <main+0xcec>
lea    0xcc0(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xcda(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xb9f(%rip),%rdi
call   1040 <system@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1e57 <main+0xd17>
cmp    $0x1,%eax
jne    1a63 <main+0x923>
lea    0x1109(%rip),%rdi
call   1030 <puts@plt>
jmp    1e57 <main+0xd17>
lea    0xd19(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xc87(%rip),%r15
lea    0x4(%rsp),%r12
mov    %r15,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0x4(%rsp),%ebp
lea    0xb42(%rip),%r13
mov    %ebp,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebp,%r14d
mov    %r13,%rdi
call   1040 <system@plt>
lea    0xccc(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r15,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0x4(%rsp),%eax
cmp    %ebx,%eax
setle  %cl
test   %eax,%eax
setg   %dl
cmp    %ebp,%eax
mov    %eax,%ebp
cmovl  %r14d,%ebp
test   %dl,%cl
cmovne %r14d,%ebp
cmovne %eax,%ebx
test   %eax,%eax
jg     1780 <main+0x640>
lea    0xae2(%rip),%rdi
call   1040 <system@plt>
lea    0xca1(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xcb8(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1e57 <main+0xd17>
lea    0xd23(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xcef(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
lea    0xa87(%rip),%r15
lea    0xd17(%rip),%r12
lea    0xd61(%rip),%r13
lea    0xb(%rsp),%rbx
lea    0xd59(%rip),%rbp
lea    0x14(%rsp),%r14
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
jmp    1896 <main+0x756>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xc8d(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movss  0xc(%rsp),%xmm0
addss  0x14(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movzbl 0xb(%rsp),%eax
cmp    $0x30,%al
je     18f6 <main+0x7b6>
mov    %r15,%rdi
call   1040 <system@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movzbl 0xb(%rsp),%eax
movsbl %al,%ecx
cmp    $0x2d,%ecx
je     1860 <main+0x720>
cmp    $0x2b,%ecx
jne    1892 <main+0x752>
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xc26(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movss  0x10(%rsp),%xmm0
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
jmp    188d <main+0x74d>
lea    0x9b5(%rip),%rdi
call   1040 <system@plt>
movss  0xc(%rsp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  %xmm2,0x20(%rsp)
movsd  0x6e6(%rip),%xmm0
mulsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm3
movss  %xmm3,0x18(%rsp)
movss  0x4(%rsp),%xmm2
subss  %xmm1,%xmm2
movss  0x10(%rsp),%xmm0
addss  %xmm0,%xmm2
subss  %xmm3,%xmm2
movss  %xmm2,0xc(%rsp)
cvtss2sd %xmm0,%xmm0
lea    0xc71(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0xc85(%rip),%rdi
movsd  0x20(%rsp),%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc84(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc82(%rip),%rdi
jmp    1e50 <main+0xd10>
lea    0x911(%rip),%r14
lea    0xb1f(%rip),%r15
lea    0xb4f(%rip),%rbx
lea    0x4(%rsp),%rbp
xorps  %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movss  %xmm1,0x10(%rsp)
mov    %r14,%rdi
call   1040 <system@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movss  0x10(%rsp),%xmm1
movss  0x4(%rsp),%xmm0
addss  %xmm0,%xmm1
ucomiss 0x778(%rip),%xmm0
ja     19c0 <main+0x880>
movss  0x762(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    1a20 <main+0x8e0>
cvtss2sd %xmm1,%xmm1
movsd  0x609(%rip),%xmm0
mulsd  %xmm1,%xmm0
jmp    1e3d <main+0xcfd>
movss  0x744(%rip),%xmm0
ucomiss %xmm1,%xmm0
jae    1a8d <main+0x94d>
movss  0x73b(%rip),%xmm0
ucomiss %xmm1,%xmm0
cvtss2sd %xmm1,%xmm1
movaps 0x73d(%rip),%xmm0
xorps  %xmm1,%xmm0
jae    1e35 <main+0xcf5>
mulsd  0x5c4(%rip),%xmm0
jmp    1e3d <main+0xcfd>
mov    $0x1,%ecx
jmp    1c18 <main+0xad8>
mov    %eax,%ecx
neg    %ecx
xor    %edx,%edx
mov    $0x1,%esi
xchg   %ax,%ax
cmp    %edx,%eax
je     172d <main+0x5ed>
add    %esi,%edx
lea    (%rcx,%rsi,1),%edi
add    $0x1,%edi
add    $0x1,%esi
cmp    $0x1,%edi
jne    1a70 <main+0x930>
jmp    1e57 <main+0xd17>
cvtss2sd %xmm1,%xmm1
movsd  0x56f(%rip),%xmm0
mulsd  %xmm1,%xmm0
jmp    1e3d <main+0xcfd>
and    $0xfffffff8,%edi
movdqa 0x6f3(%rip),%xmm3
movdqa %xmm3,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
pshufd $0xf5,%xmm3,%xmm5
pmuludq %xmm1,%xmm5
pmuludq %xmm0,%xmm3
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm1,%xmm4
pmuludq %xmm0,%xmm2
pmuludq %xmm0,%xmm3
pmuludq %xmm1,%xmm5
pmuludq %xmm0,%xmm2
pmuludq %xmm1,%xmm4
pmuludq %xmm1,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm1,%xmm4
pmuludq %xmm0,%xmm2
pmuludq %xmm0,%xmm3
pmuludq %xmm1,%xmm5
pmuludq %xmm0,%xmm2
pmuludq %xmm1,%xmm4
pmuludq %xmm1,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm1,%xmm4
pmuludq %xmm0,%xmm2
pmuludq %xmm0,%xmm3
pmuludq %xmm1,%xmm5
pmuludq %xmm0,%xmm2
pmuludq %xmm1,%xmm4
pmuludq %xmm1,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm1,%xmm4
pmuludq %xmm0,%xmm2
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm1,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm3
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm1,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm2
add    $0xfffffff8,%edi
jne    1ac0 <main+0x980>
movdqa %xmm3,%xmm4
movdqa %xmm2,%xmm5
test   %ecx,%ecx
je     1bcb <main+0xa8b>
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm4
movdqa %xmm0,%xmm3
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm5
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm1,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm5
movdqa %xmm4,%xmm3
movdqa %xmm5,%xmm2
add    $0xffffffff,%ecx
jne    1b80 <main+0xa40>
pshufd $0xf5,%xmm4,%xmm0
pshufd $0xf5,%xmm5,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm4,%xmm5
pshufd $0xee,%xmm5,%xmm0
pmuludq %xmm5,%xmm0
pshufd $0xaa,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pmuludq %xmm0,%xmm2
movd   %xmm2,%ecx
cmp    %eax,%edx
je     1c18 <main+0xad8>
or     $0x1,%eax
mov    %edx,%edi
sub    %eax,%edi
add    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
nop
imul   %esi,%ecx
add    $0xffffffff,%edi
jne    1c10 <main+0xad0>
lea    0x738(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1e57 <main+0xd17>
and    $0xfffffffc,%edx
movdqa 0x56a(%rip),%xmm1
movdqa 0x581(%rip),%xmm9
movdqa 0x588(%rip),%xmm10
movdqa 0x58f(%rip),%xmm11
movdqa 0x596(%rip),%xmm12
movdqa 0x59d(%rip),%xmm13
movdqa 0x5a4(%rip),%xmm14
movdqa 0x5ab(%rip),%xmm15
movdqa %xmm1,%xmm2
nopl   0x0(%rax)
movdqa %xmm6,%xmm0
paddd  0x524(%rip),%xmm0
pshufd $0xf5,%xmm6,%xmm7
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm7,%xmm3
pmuludq %xmm6,%xmm1
pshufd $0xf5,%xmm2,%xmm7
pshufd $0xf5,%xmm0,%xmm4
pmuludq %xmm7,%xmm4
pmuludq %xmm2,%xmm0
movdqa %xmm6,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm6,%xmm7
paddd  %xmm10,%xmm7
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm3,%xmm2
pmuludq %xmm7,%xmm0
pshufd $0xf5,%xmm7,%xmm3
pmuludq %xmm4,%xmm3
movdqa %xmm6,%xmm4
paddd  %xmm11,%xmm4
movdqa %xmm6,%xmm7
paddd  %xmm12,%xmm7
pshufd $0xf5,%xmm4,%xmm5
pmuludq %xmm2,%xmm5
pmuludq %xmm1,%xmm4
pshufd $0xf5,%xmm7,%xmm8
pmuludq %xmm3,%xmm8
pmuludq %xmm0,%xmm7
movdqa %xmm6,%xmm0
paddd  %xmm13,%xmm0
movdqa %xmm6,%xmm3
paddd  %xmm14,%xmm3
pmuludq %xmm0,%xmm4
pshufd $0xe8,%xmm4,%xmm1
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm5,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
pmuludq %xmm3,%xmm7
pshufd $0xe8,%xmm7,%xmm2
pshufd $0xf5,%xmm3,%xmm0
pmuludq %xmm8,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
paddd  %xmm15,%xmm6
add    $0xfffffffc,%edx
jne    1c80 <main+0xb40>
test   %ecx,%ecx
je     1dd1 <main+0xc91>
movdqa 0x443(%rip),%xmm3
movdqa 0x44b(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm6,%xmm0
paddd  %xmm3,%xmm0
pshufd $0xf5,%xmm1,%xmm5
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm6,%xmm7
pmuludq %xmm5,%xmm7
pshufd $0xe8,%xmm7,%xmm5
punpckldq %xmm5,%xmm1
pshufd $0xf5,%xmm2,%xmm5
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm5,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
paddd  %xmm4,%xmm6
add    $0xffffffff,%ecx
jne    1d80 <main+0xc40>
pshufd $0xf5,%xmm1,%xmm0
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm0,%xmm3
pmuludq %xmm1,%xmm2
pshufd $0xee,%xmm2,%xmm0
pmuludq %xmm2,%xmm0
pshufd $0xaa,%xmm3,%xmm1
pmuludq %xmm3,%xmm1
pmuludq %xmm0,%xmm1
movd   %xmm1,%edx
cmp    %eax,%esi
je     1e1d <main+0xcdd>
mov    %esi,%eax
and    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
imul   %eax,%edx
lea    -0x1(%rax),%ecx
cmp    $0x1,%eax
mov    %ecx,%eax
ja     1e10 <main+0xcd0>
movl   $0x0,0x4(%rsp)
lea    0x568(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1e57 <main+0xd17>
mulsd  0x1d3(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x6b1(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [88 x i8] c"\09\09-----------------------------------------------------------------------------------\0A\0A\00"
@.str.1 = [43 x i8] c"\09\09LISTA DOS EXERCICIOS DO DIA 08/11/2017\0A\0A\00"
@.str.2 = [60 x i8] c"\09\09ESCOLHA UMA DAS OPCOES ABAIXO PARA EXECUTAR O EXERCICIO\0A\0A\00"
@.str.3 = [38 x i8] c"\09\09EXERCICIO 1 - CONTAGEM REGRESSIVA\0A\0A\00"
@.str.4 = [38 x i8] c"\09\09EXERCICIO 2 - POLEGADA/CENTIMETRO\0A\0A\00"
@.str.5 = [27 x i8] c"\09\09EXERCICIO 3 - POTENCIA\0A\0A\00"
@.str.6 = [47 x i8] c"\09\09EXERCICIO 4 - FATORIAL (SEM RECURSIVIDADE)\0A\0A\00"
@.str.7 = [47 x i8] c"\09\09EXERCICIO 5 - POTENCIA COM SOMA DE IMPARES\0A\0A\00"
@.str.8 = [30 x i8] c"\09\09EXERCICIO 6 - CONTA BANCO\0A\0A\00"
@.str.9 = [29 x i8] c"\09\09EXERCICIO 7 - TRIANGULAR\0A\0A\00"
@.str.10 = [36 x i8] c"\09\09EXERCICIO 8 - MAIOR/MENOR IDADE\0A\0A\00"
@.str.11 = [24 x i8] c"\09\09EXERCICIO 9 - CAIXA\0A\0A\00"
@.str.12 = [31 x i8] c"\09\09EXERCICIO 10 - SALDO BANCO\0A\0A\00"
@.str.13 = [90 x i8] c"\09\09-----------------------------------------------------------------------------------\0A\0A\09\09\00"
@.str.14 = [3 x i8] c"%i\00"
@.str.15 = [4 x i8] c"cls\00"
@.str.16 = [32 x i8] c"\09\09Digite um numero qualquer\0A\0A\09\09\00"
@.str.17 = [5 x i8] c"\0A %i\00"
@.str.18 = [50 x i8] c"\0A\0A\09\09%.2f polegada equivale a %.2f centimetros\09\09\0A\0A\00"
@.str.19 = [25 x i8] c"\0A\0A\09\09Digite um numero\0A\0A\09\09\00"
@.str.20 = [49 x i8] c"\0A\0A\09\09Digite um outro numero para ser potencia\0A\0A\09\09\00"
@.str.21 = [25 x i8] c"\0A\0A\09\09%i elevado a %i = %i\00"
@.str.22 = [36 x i8] c"\09\09Digite o numero para fatorar:\0A\0A\09\09\00"
@.str.23 = [30 x i8] c"\0A\0A\09\09O fatorial de %i e = %i\0A\0A\00"
@.str.24 = [40 x i8] c"\09\09Digite um numero natural qualquer\0A\0A\09\09\00"
@.str.25 = [3 x i8] c"%d\00"
@.str.26 = [60 x i8] c"\09\09O quadrado do numero digitado na soma de impares e = %d\0A\0A\00"
@.str.27 = [31 x i8] c"\09\09Digite o numero da conta\0A\0A\09\09\00"
@.str.28 = [38 x i8] c"\09\09Numero de conta completo: 00%d-%d\0A\0A\00"
@.str.29 = [36 x i8] c"\09\09O NUMERO DIGITADO E TRIANGULAR!\0A\0A\00"
@.str.30 = [40 x i8] c"\09\09O NUMERO DIGITADO NAO E TRIANGULAR!\0A\0A\00"
@.str.31 = [31 x i8] c"\09\09Digite a idade da pessoa\0A\0A\09\09\00"
@.str.32 = [39 x i8] c"\0A\0A\09\09A menor idade digitada foi: %d\0A\0A\09\09\00"
@.str.33 = [35 x i8] c"A maior idade digitada foi: %d\0A\0A\09\09\00"
@.str.34 = [55 x i8] c"\09\09Digite o preco do produto (0 para TOTAL A PAGAR)\0A\0A\09\09\00"
@.str.35 = [3 x i8] c"%f\00"
@.str.36 = [35 x i8] c"\0A\0A\09\09O cliente deve pagar R$ %.2f\0A\0A\00"
@.str.37 = [37 x i8] c"\09\09Qual o saldo inicial da conta?\0A\0A\09\09\00"
@.str.38 = [81 x i8] c"\09\09Digite o codigo da operacao de credito (+) ou debito (-) (0 PARA VER SALDO)\0A\09\09\00"
@.str.39 = [4 x i8] c" %c\00"
@.str.40 = [36 x i8] c"\0A\0A\09\09Digite o valor da operacao:\0A\0A\09\09\00"
@.str.41 = [34 x i8] c"\0A\0A\09\09TOTAL DE CREDITOS: R$ %.2f\0A\09\09\00"
@.str.42 = [29 x i8] c"TOTAL DE DEBITOS: R$ %.2f\0A\09\09\00"
@.str.43 = [22 x i8] c"CPFM PAGA: R$ %.2f\0A\09\09\00"
@.str.44 = [25 x i8] c"SALDO FINAL: R$ %.2f\0A\0A\09\09\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca float
%6 = alloca float
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%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 i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca i8
store i32 0, i32* %1
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str, i64 0, i64 0))
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.2, i64 0, i64 0))
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str, i64 0, i64 0))
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.3, i64 0, i64 0))
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.4, i64 0, i64 0))
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.5, i64 0, i64 0))
%46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.6, i64 0, i64 0))
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.7, i64 0, i64 0))
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0))
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.9, i64 0, i64 0))
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.10, i64 0, i64 0))
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.11, i64 0, i64 0))
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.12, i64 0, i64 0))
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.13, i64 0, i64 0))
%54 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %2)
%55 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%56 = load i32, i32* %2
switch i32 %56, label %356 [
i32 1, label %57
i32 2, label %72
i32 3, label %92
i32 4, label %113
i32 5, label %131
i32 6, label %151
i32 7, label %173
i32 8, label %204
i32 9, label %238
i32 10, label %305
]
57: ; preds = %0
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.16, i64 0, i64 0))
%59 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %4)
%60 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
store i32 0, i32* %3
br label %61
61: ; preds = %68, %57
%62 = load i32, i32* %3
%63 = load i32, i32* %4
%64 = icmp sle i32 %62, %63
br i1 %64, label %65, label %71
65: ; preds = %61
%66 = load i32, i32* %4
%67 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0), i32 %66)
br label %68
68: ; preds = %65
%69 = load i32, i32* %4
%70 = add nsw i32 %69, -1
store i32 %70, i32* %4
br label %61
71: ; preds = %61
br label %356
72: ; preds = %0
store float 0.000000e+00, float* %5
br label %73
73: ; preds = %86, %72
%74 = load float, float* %5
%75 = fcmp ole float %74, 1.000000e+01
br i1 %75, label %76, label %91
76: ; preds = %73
%77 = load float, float* %5
%78 = fpext float %77 to double
%79 = fmul double %78, 2.540000e+00
%80 = fptrunc double %79 to float
store float %80, float* %6
%81 = load float, float* %5
%82 = fpext float %81 to double
%83 = load float, float* %6
%84 = fpext float %83 to double
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double %82, double %84)
br label %86
86: ; preds = %76
%87 = load float, float* %5
%88 = fpext float %87 to double
%89 = fadd double %88, 5.000000e-01
%90 = fptrunc double %89 to float
store float %90, float* %5
br label %73
91: ; preds = %73
br label %356
92: ; preds = %0
store i32 1, i32* %10
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.19, i64 0, i64 0))
%94 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %7)
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.20, i64 0, i64 0))
%96 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %8)
store i32 1, i32* %9
br label %97
97: ; preds = %105, %92
%98 = load i32, i32* %9
%99 = load i32, i32* %8
%100 = icmp sle i32 %98, %99
br i1 %100, label %101, label %108
101: ; preds = %97
%102 = load i32, i32* %7
%103 = load i32, i32* %10
%104 = mul nsw i32 %103, %102
store i32 %104, i32* %10
br label %105
105: ; preds = %101
%106 = load i32, i32* %9
%107 = add nsw i32 %106, 1
store i32 %107, i32* %9
br label %97
108: ; preds = %97
%109 = load i32, i32* %7
%110 = load i32, i32* %8
%111 = load i32, i32* %10
%112 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.21, i64 0, i64 0), i32 %109, i32 %110, i32 %111)
br label %356
113: ; preds = %0
store i32 1, i32* %13
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.22, i64 0, i64 0))
%115 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %11)
%116 = load i32, i32* %11
store i32 %116, i32* %12
br label %117
117: ; preds = %124, %113
%118 = load i32, i32* %11
%119 = icmp sge i32 %118, 1
br i1 %119, label %120, label %127
120: ; preds = %117
%121 = load i32, i32* %11
%122 = load i32, i32* %13
%123 = mul nsw i32 %122, %121
store i32 %123, i32* %13
br label %124
124: ; preds = %120
%125 = load i32, i32* %11
%126 = add nsw i32 %125, -1
store i32 %126, i32* %11
br label %117
127: ; preds = %117
%128 = load i32, i32* %12
%129 = load i32, i32* %13
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.23, i64 0, i64 0), i32 %128, i32 %129)
br label %356
131: ; preds = %0
store i32 0, i32* %16
%132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.24, i64 0, i64 0))
%133 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %14)
%134 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
store i32 0, i32* %15
br label %135
135: ; preds = %145, %131
%136 = load i32, i32* %15
%137 = load i32, i32* %14
%138 = icmp slt i32 %136, %137
br i1 %138, label %139, label %148
139: ; preds = %135
%140 = load i32, i32* %15
%141 = mul nsw i32 %140, 2
%142 = add nsw i32 %141, 1
%143 = load i32, i32* %16
%144 = add nsw i32 %143, %142
store i32 %144, i32* %16
br label %145
145: ; preds = %139
%146 = load i32, i32* %15
%147 = add nsw i32 %146, 1
store i32 %147, i32* %15
br label %135
148: ; preds = %135
%149 = load i32, i32* %16
%150 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.26, i64 0, i64 0), i32 %149)
br label %356
151: ; preds = %0
store i32 0, i32* %18
%152 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.27, i64 0, i64 0))
%153 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %17)
%154 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%155 = load i32, i32* %17
store i32 %155, i32* %21
br label %156
156: ; preds = %159, %151
%157 = load i32, i32* %17
%158 = icmp ne i32 %157, 0
br i1 %158, label %159, label %167
159: ; preds = %156
%160 = load i32, i32* %17
%161 = srem i32 %160, 10
store i32 %161, i32* %19
%162 = load i32, i32* %17
%163 = sdiv i32 %162, 10
store i32 %163, i32* %17
%164 = load i32, i32* %19
%165 = load i32, i32* %18
%166 = add nsw i32 %165, %164
store i32 %166, i32* %18
br label %156
167: ; preds = %156
%168 = load i32, i32* %18
%169 = srem i32 %168, 10
store i32 %169, i32* %20
%170 = load i32, i32* %21
%171 = load i32, i32* %20
%172 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.28, i64 0, i64 0), i32 %170, i32 %171)
br label %356
173: ; preds = %0
store i32 0, i32* %23
%174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.24, i64 0, i64 0))
%175 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %22)
%176 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
store i32 1, i32* %24
br label %177
177: ; preds = %195, %173
%178 = load i32, i32* %24
%179 = load i32, i32* %22
%180 = icmp sle i32 %178, %179
br i1 %180, label %181, label %198
181: ; preds = %177
%182 = load i32, i32* %22
%183 = load i32, i32* %23
%184 = icmp eq i32 %182, %183
br i1 %184, label %188, label %185
185: ; preds = %181
%186 = load i32, i32* %22
%187 = icmp eq i32 %186, 1
br i1 %187, label %188, label %190
188: ; preds = %185, %181
%189 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.29, i64 0, i64 0))
store i32 1, i32* %25
br label %198
190: ; preds = %185
%191 = load i32, i32* %24
%192 = load i32, i32* %23
%193 = add nsw i32 %192, %191
store i32 %193, i32* %23
br label %194
194: ; preds = %190
br label %195
195: ; preds = %194
%196 = load i32, i32* %24
%197 = add nsw i32 %196, 1
store i32 %197, i32* %24
br label %177
198: ; preds = %188, %177
%199 = load i32, i32* %25
%200 = icmp ne i32 %199, 1
br i1 %200, label %201, label %203
201: ; preds = %198
%202 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.30, i64 0, i64 0))
br label %203
203: ; preds = %201, %198
br label %356
204: ; preds = %0
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.31, i64 0, i64 0))
%206 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %26)
%207 = load i32, i32* %26
store i32 %207, i32* %28
%208 = load i32, i32* %26
store i32 %208, i32* %27
br label %209
209: ; preds = %229, %204
%210 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%211 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.31, i64 0, i64 0))
%212 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %26)
%213 = load i32, i32* %26
%214 = load i32, i32* %28
%215 = icmp sle i32 %213, %214
br i1 %215, label %216, label %221
216: ; preds = %209
%217 = load i32, i32* %26
%218 = icmp sgt i32 %217, 0
br i1 %218, label %219, label %221
219: ; preds = %216
%220 = load i32, i32* %26
store i32 %220, i32* %28
br label %228
221: ; preds = %216, %209
%222 = load i32, i32* %26
%223 = load i32, i32* %27
%224 = icmp sge i32 %222, %223
br i1 %224, label %225, label %227
225: ; preds = %221
%226 = load i32, i32* %26
store i32 %226, i32* %27
br label %227
227: ; preds = %225, %221
br label %228
228: ; preds = %227, %219
br label %229
229: ; preds = %228
%230 = load i32, i32* %26
%231 = icmp sgt i32 %230, 0
br i1 %231, label %209, label %232
232: ; preds = %229
%233 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%234 = load i32, i32* %28
%235 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.32, i64 0, i64 0), i32 %234)
%236 = load i32, i32* %27
%237 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.33, i64 0, i64 0), i32 %236)
br label %356
238: ; preds = %0
store float 0.000000e+00, float* %30
store float 0.000000e+00, float* %31
br label %239
239: ; preds = %246, %238
%240 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%241 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.34, i64 0, i64 0))
%242 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), float* %29)
%243 = load float, float* %29
%244 = load float, float* %30
%245 = fadd float %244, %243
store float %245, float* %30
br label %246
246: ; preds = %239
%247 = load float, float* %29
%248 = fcmp ogt float %247, 0.000000e+00
br i1 %248, label %239, label %249
249: ; preds = %246
%250 = load float, float* %30
%251 = fcmp olt float %250, 5.000000e+01
br i1 %251, label %252, label %263
252: ; preds = %249
%253 = load float, float* %30
%254 = fpext float %253 to double
%255 = load float, float* %30
%256 = fpext float %255 to double
%257 = fneg double %256
%258 = call double @llvm.fmuladd.f64(double %257, double 5.000000e-02, double %254)
%259 = fptrunc double %258 to float
store float %259, float* %31
%260 = load float, float* %31
%261 = fpext float %260 to double
%262 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.36, i64 0, i64 0), double %261)
br label %304
263: ; preds = %249
%264 = load float, float* %30
%265 = fcmp ole float %264, 1.000000e+02
br i1 %265, label %266, label %277
266: ; preds = %263
%267 = load float, float* %30
%268 = fpext float %267 to double
%269 = load float, float* %30
%270 = fpext float %269 to double
%271 = fneg double %270
%272 = call double @llvm.fmuladd.f64(double %271, double 1.000000e-01, double %268)
%273 = fptrunc double %272 to float
store float %273, float* %31
%274 = load float, float* %31
%275 = fpext float %274 to double
%276 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.36, i64 0, i64 0), double %275)
br label %303
277: ; preds = %263
%278 = load float, float* %30
%279 = fcmp ole float %278, 2.000000e+02
br i1 %279, label %280, label %291
280: ; preds = %277
%281 = load float, float* %30
%282 = fpext float %281 to double
%283 = load float, float* %30
%284 = fpext float %283 to double
%285 = fneg double %284
%286 = call double @llvm.fmuladd.f64(double %285, double 1.500000e-01, double %282)
%287 = fptrunc double %286 to float
store float %287, float* %31
%288 = load float, float* %31
%289 = fpext float %288 to double
%290 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.36, i64 0, i64 0), double %289)
br label %302
291: ; preds = %277
%292 = load float, float* %30
%293 = fpext float %292 to double
%294 = load float, float* %30
%295 = fpext float %294 to double
%296 = fneg double %295
%297 = call double @llvm.fmuladd.f64(double %296, double 2.000000e-01, double %293)
%298 = fptrunc double %297 to float
store float %298, float* %31
%299 = load float, float* %31
%300 = fpext float %299 to double
%301 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.36, i64 0, i64 0), double %300)
br label %302
302: ; preds = %291, %280
br label %303
303: ; preds = %302, %266
br label %304
304: ; preds = %303, %252
br label %356
305: ; preds = %0
store float 0.000000e+00, float* %33
store float 0.000000e+00, float* %34
store float 0.000000e+00, float* %35
store float 0.000000e+00, float* %36
%306 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.37, i64 0, i64 0))
%307 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), float* %32)
br label %308
308: ; preds = %327, %305
%309 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%310 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.38, i64 0, i64 0))
%311 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.39, i64 0, i64 0), i8* %38)
%312 = load i8, i8* %38
%313 = sext i8 %312 to i32
switch i32 %313, label %326 [
i32 43, label %314
i32 45, label %320
]
314: ; preds = %308
%315 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.40, i64 0, i64 0))
%316 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), float* %37)
%317 = load float, float* %37
%318 = load float, float* %33
%319 = fadd float %318, %317
store float %319, float* %33
br label %326
320: ; preds = %308
%321 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.40, i64 0, i64 0))
%322 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), float* %37)
%323 = load float, float* %37
%324 = load float, float* %34
%325 = fadd float %324, %323
store float %325, float* %34
br label %326
326: ; preds = %308, %320, %314
br label %327
327: ; preds = %326
%328 = load i8, i8* %38
%329 = sext i8 %328 to i32
%330 = icmp ne i32 %329, 48
br i1 %330, label %308, label %331
331: ; preds = %327
%332 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%333 = load float, float* %34
%334 = fpext float %333 to double
%335 = fmul double %334, 3.500000e-03
%336 = fptrunc double %335 to float
store float %336, float* %35
%337 = load float, float* %32
%338 = load float, float* %34
%339 = fsub float %337, %338
%340 = load float, float* %33
%341 = fadd float %339, %340
%342 = load float, float* %35
%343 = fsub float %341, %342
store float %343, float* %36
%344 = load float, float* %33
%345 = fpext float %344 to double
%346 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.41, i64 0, i64 0), double %345)
%347 = load float, float* %34
%348 = fpext float %347 to double
%349 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.42, i64 0, i64 0), double %348)
%350 = load float, float* %35
%351 = fpext float %350 to double
%352 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.43, i64 0, i64 0), double %351)
%353 = load float, float* %36
%354 = fpext float %353 to double
%355 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.44, i64 0, i64 0), double %354)
br label %356
356: ; preds = %0, %331, %304, %232, %203, %167, %148, %127, %108, %91, %71
ret i32 0
}

LLVM IR (-O2):
@.str.13 = [90 x i8] c"\09\09-----------------------------------------------------------------------------------\0A\0A\09\09\00"
@.str.14 = [3 x i8] c"%i\00"
@.str.15 = [4 x i8] c"cls\00"
@.str.16 = [32 x i8] c"\09\09Digite um numero qualquer\0A\0A\09\09\00"
@.str.17 = [5 x i8] c"\0A %i\00"
@.str.18 = [50 x i8] c"\0A\0A\09\09%.2f polegada equivale a %.2f centimetros\09\09\0A\0A\00"
@.str.19 = [25 x i8] c"\0A\0A\09\09Digite um numero\0A\0A\09\09\00"
@.str.20 = [49 x i8] c"\0A\0A\09\09Digite um outro numero para ser potencia\0A\0A\09\09\00"
@.str.21 = [25 x i8] c"\0A\0A\09\09%i elevado a %i = %i\00"
@.str.22 = [36 x i8] c"\09\09Digite o numero para fatorar:\0A\0A\09\09\00"
@.str.23 = [30 x i8] c"\0A\0A\09\09O fatorial de %i e = %i\0A\0A\00"
@.str.24 = [40 x i8] c"\09\09Digite um numero natural qualquer\0A\0A\09\09\00"
@.str.25 = [3 x i8] c"%d\00"
@.str.26 = [60 x i8] c"\09\09O quadrado do numero digitado na soma de impares e = %d\0A\0A\00"
@.str.27 = [31 x i8] c"\09\09Digite o numero da conta\0A\0A\09\09\00"
@.str.28 = [38 x i8] c"\09\09Numero de conta completo: 00%d-%d\0A\0A\00"
@.str.31 = [31 x i8] c"\09\09Digite a idade da pessoa\0A\0A\09\09\00"
@.str.32 = [39 x i8] c"\0A\0A\09\09A menor idade digitada foi: %d\0A\0A\09\09\00"
@.str.33 = [35 x i8] c"A maior idade digitada foi: %d\0A\0A\09\09\00"
@.str.34 = [55 x i8] c"\09\09Digite o preco do produto (0 para TOTAL A PAGAR)\0A\0A\09\09\00"
@.str.35 = [3 x i8] c"%f\00"
@.str.36 = [35 x i8] c"\0A\0A\09\09O cliente deve pagar R$ %.2f\0A\0A\00"
@.str.37 = [37 x i8] c"\09\09Qual o saldo inicial da conta?\0A\0A\09\09\00"
@.str.38 = [81 x i8] c"\09\09Digite o codigo da operacao de credito (+) ou debito (-) (0 PARA VER SALDO)\0A\09\09\00"
@.str.39 = [4 x i8] c" %c\00"
@.str.40 = [36 x i8] c"\0A\0A\09\09Digite o valor da operacao:\0A\0A\09\09\00"
@.str.41 = [34 x i8] c"\0A\0A\09\09TOTAL DE CREDITOS: R$ %.2f\0A\09\09\00"
@.str.42 = [29 x i8] c"TOTAL DE DEBITOS: R$ %.2f\0A\09\09\00"
@.str.43 = [22 x i8] c"CPFM PAGA: R$ %.2f\0A\09\09\00"
@.str.44 = [25 x i8] c"SALDO FINAL: R$ %.2f\0A\0A\09\09\00"
@str.45 = [42 x i8] c"\09\09LISTA DOS EXERCICIOS DO DIA 08/11/2017\0A\00"
@str.46 = [59 x i8] c"\09\09ESCOLHA UMA DAS OPCOES ABAIXO PARA EXECUTAR O EXERCICIO\0A\00"
@str.47 = [87 x i8] c"\09\09-----------------------------------------------------------------------------------\0A\00"
@str.48 = [37 x i8] c"\09\09EXERCICIO 1 - CONTAGEM REGRESSIVA\0A\00"
@str.49 = [37 x i8] c"\09\09EXERCICIO 2 - POLEGADA/CENTIMETRO\0A\00"
@str.50 = [26 x i8] c"\09\09EXERCICIO 3 - POTENCIA\0A\00"
@str.51 = [46 x i8] c"\09\09EXERCICIO 4 - FATORIAL (SEM RECURSIVIDADE)\0A\00"
@str.52 = [46 x i8] c"\09\09EXERCICIO 5 - POTENCIA COM SOMA DE IMPARES\0A\00"
@str.53 = [29 x i8] c"\09\09EXERCICIO 6 - CONTA BANCO\0A\00"
@str.54 = [28 x i8] c"\09\09EXERCICIO 7 - TRIANGULAR\0A\00"
@str.55 = [35 x i8] c"\09\09EXERCICIO 8 - MAIOR/MENOR IDADE\0A\00"
@str.56 = [23 x i8] c"\09\09EXERCICIO 9 - CAIXA\0A\00"
@str.57 = [30 x i8] c"\09\09EXERCICIO 10 - SALDO BANCO\0A\00"
@str.58 = [35 x i8] c"\09\09O NUMERO DIGITADO E TRIANGULAR!\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca i8
%14 = bitcast i32* %1 to i8*
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([87 x i8], [87 x i8]* @str.47, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.45, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @str.46, i64 0, i64 0))
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([87 x i8], [87 x i8]* @str.47, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str.48, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str.49, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.50, i64 0, i64 0))
%22 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str.51, i64 0, i64 0))
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str.52, i64 0, i64 0))
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.53, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.54, i64 0, i64 0))
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @str.55, i64 0, i64 0))
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.56, i64 0, i64 0))
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.57, i64 0, i64 0))
%29 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @.str.13, i64 0, i64 0))
%30 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %1)
%31 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%32 = load i32, i32* %1
switch i32 %32, label %395 [
i32 1, label %55
i32 2, label %33
i32 3, label %69
i32 4, label %149
i32 5, label %231
i32 6, label %249
i32 7, label %269
i32 8, label %289
i32 9, label %312
i32 10, label %347
]
33: ; preds = %0
%34 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 0.000000e+00, double 0.000000e+00)
%35 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 5.000000e-01, double 0x3FF451EB80000000)
%36 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 1.000000e+00, double 0x400451EB80000000)
%37 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 1.500000e+00, double 0x400E7AE140000000)
%38 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 2.000000e+00, double 0x401451EB80000000)
%39 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 2.500000e+00, double 0x4019666660000000)
%40 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 3.000000e+00, double 0x401E7AE140000000)
%41 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 3.500000e+00, double 0x4021C7AE20000000)
%42 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 4.000000e+00, double 0x402451EB80000000)
%43 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 4.500000e+00, double 0x4026DC2900000000)
%44 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 5.000000e+00, double 0x4029666660000000)
%45 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 5.500000e+00, double 0x402BF0A3E0000000)
%46 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 6.000000e+00, double 0x402E7AE140000000)
%47 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 6.500000e+00, double 0x4030828F60000000)
%48 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 7.000000e+00, double 0x4031C7AE20000000)
%49 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 7.500000e+00, double 0x40330CCCC0000000)
%50 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 8.000000e+00, double 0x403451EB80000000)
%51 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 8.500000e+00, double 0x4035970A40000000)
%52 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 9.000000e+00, double 0x4036DC2900000000)
%53 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 9.500000e+00, double 0x40382147A0000000)
%54 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.18, i64 0, i64 0), double 1.000000e+01, double 0x4039666660000000)
br label %395
55: ; preds = %0
%56 = bitcast i32* %2 to i8*
%57 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.16, i64 0, i64 0))
%58 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %2)
%59 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%60 = load i32, i32* %2
%61 = icmp sgt i32 %60, -1
br i1 %61, label %62, label %68
62: ; preds = %55, %62
%63 = phi i32 [ %66, %62 ], [ %60, %55 ]
%64 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0), i32 %63)
%65 = load i32, i32* %2
%66 = add nsw i32 %65, -1
store i32 %66, i32* %2
%67 = icmp sgt i32 %65, 0
br i1 %67, label %62, label %68
68: ; preds = %62, %55
br label %395
69: ; preds = %0
%70 = bitcast i32* %3 to i8*
%71 = bitcast i32* %4 to i8*
%72 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.19, i64 0, i64 0))
%73 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %3)
%74 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.20, i64 0, i64 0))
%75 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %4)
%76 = load i32, i32* %4
%77 = icmp slt i32 %76, 1
%78 = load i32, i32* %3
br i1 %77, label %146, label %79
79: ; preds = %69
%80 = icmp ult i32 %76, 8
br i1 %80, label %137, label %81
81: ; preds = %79
%82 = and i32 %76, -8
%83 = or i32 %82, 1
%84 = insertelement <4 x i32> poison, i32 %78, i64 0
%85 = shufflevector <4 x i32> %84, <4 x i32> poison, <4 x i32> zeroinitializer
%86 = insertelement <4 x i32> poison, i32 %78, i64 0
%87 = shufflevector <4 x i32> %86, <4 x i32> poison, <4 x i32> zeroinitializer
%88 = add i32 %82, -8
%89 = lshr exact i32 %88, 3
%90 = add nuw nsw i32 %89, 1
%91 = and i32 %90, 7
%92 = icmp ult i32 %88, 56
br i1 %92, label %117, label %93
93: ; preds = %81
%94 = and i32 %90, 1073741816
br label %95
95: ; preds = %95, %93
%96 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %93 ], [ %113, %95 ]
%97 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %93 ], [ %114, %95 ]
%98 = phi i32 [ 0, %93 ], [ %115, %95 ]
%99 = mul <4 x i32> %85, %96
%100 = mul <4 x i32> %87, %97
%101 = mul <4 x i32> %85, %99
%102 = mul <4 x i32> %87, %100
%103 = mul <4 x i32> %85, %101
%104 = mul <4 x i32> %87, %102
%105 = mul <4 x i32> %85, %103
%106 = mul <4 x i32> %87, %104
%107 = mul <4 x i32> %85, %105
%108 = mul <4 x i32> %87, %106
%109 = mul <4 x i32> %85, %107
%110 = mul <4 x i32> %87, %108
%111 = mul <4 x i32> %85, %109
%112 = mul <4 x i32> %87, %110
%113 = mul <4 x i32> %85, %111
%114 = mul <4 x i32> %87, %112
%115 = add nuw i32 %98, 8
%116 = icmp eq i32 %115, %94
br i1 %116, label %117, label %95
117: ; preds = %95, %81
%118 = phi <4 x i32> [ undef, %81 ], [ %113, %95 ]
%119 = phi <4 x i32> [ undef, %81 ], [ %114, %95 ]
%120 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %81 ], [ %113, %95 ]
%121 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %81 ], [ %114, %95 ]
%122 = icmp eq i32 %91, 0
br i1 %122, label %131, label %123
123: ; preds = %117, %123
%124 = phi <4 x i32> [ %127, %123 ], [ %120, %117 ]
%125 = phi <4 x i32> [ %128, %123 ], [ %121, %117 ]
%126 = phi i32 [ %129, %123 ], [ 0, %117 ]
%127 = mul <4 x i32> %85, %124
%128 = mul <4 x i32> %87, %125
%129 = add i32 %126, 1
%130 = icmp eq i32 %129, %91
br i1 %130, label %131, label %123
131: ; preds = %123, %117
%132 = phi <4 x i32> [ %118, %117 ], [ %127, %123 ]
%133 = phi <4 x i32> [ %119, %117 ], [ %128, %123 ]
%134 = mul <4 x i32> %133, %132
%135 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %134)
%136 = icmp eq i32 %76, %82
br i1 %136, label %146, label %137
137: ; preds = %79, %131
%138 = phi i32 [ 1, %79 ], [ %83, %131 ]
%139 = phi i32 [ 1, %79 ], [ %135, %131 ]
br label %140
140: ; preds = %137, %140
%141 = phi i32 [ %144, %140 ], [ %138, %137 ]
%142 = phi i32 [ %143, %140 ], [ %139, %137 ]
%143 = mul nsw i32 %78, %142
%144 = add nuw i32 %141, 1
%145 = icmp eq i32 %141, %76
br i1 %145, label %146, label %140
146: ; preds = %140, %131, %69
%147 = phi i32 [ 1, %69 ], [ %135, %131 ], [ %143, %140 ]
%148 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.21, i64 0, i64 0), i32 %78, i32 %76, i32 %147)
br label %395
149: ; preds = %0
%150 = bitcast i32* %5 to i8*
%151 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.22, i64 0, i64 0))
%152 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32* %5)
%153 = load i32, i32* %5
%154 = icmp sgt i32 %153, 0
br i1 %154, label %155, label %228
155: ; preds = %149
%156 = icmp ult i32 %153, 8
br i1 %156, label %217, label %157
157: ; preds = %155
%158 = and i32 %153, -8
%159 = and i32 %153, 7
%160 = insertelement <4 x i32> poison, i32 %153, i64 0
%161 = shufflevector <4 x i32> %160, <4 x i32> poison, <4 x i32> zeroinitializer
%162 = add <4 x i32> %161, <i32 0, i32 -1, i32 -2, i32 -3>
%163 = add i32 %158, -8
%164 = lshr exact i32 %163, 3
%165 = add nuw nsw i32 %164, 1
%166 = and i32 %165, 3
%167 = icmp ult i32 %163, 24
br i1 %167, label %193, label %168
168: ; preds = %157
%169 = and i32 %165, 1073741820
br label %170
170: ; preds = %170, %168
%171 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %168 ], [ %188, %170 ]
%172 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %168 ], [ %189, %170 ]
%173 = phi <4 x i32> [ %162, %168 ], [ %190, %170 ]
%174 = phi i32 [ 0, %168 ], [ %191, %170 ]
%175 = add <4 x i32> %173, <i32 -4, i32 -4, i32 -4, i32 -4>
%176 = mul <4 x i32> %171, %173
%177 = mul <4 x i32> %172, %175
%178 = add <4 x i32> %173, <i32 -8, i32 -8, i32 -8, i32 -8>
%179 = add <4 x i32> %173, <i32 -12, i32 -12, i32 -12, i32 -12>
%180 = mul <4 x i32> %176, %178
%181 = mul <4 x i32> %177, %179
%182 = add <4 x i32> %173, <i32 -16, i32 -16, i32 -16, i32 -16>
%183 = add <4 x i32> %173, <i32 -20, i32 -20, i32 -20, i32 -20>
%184 = mul <4 x i32> %180, %182
%185 = mul <4 x i32> %181, %183
%186 = add <4 x i32> %173, <i32 -24, i32 -24, i32 -24, i32 -24>
%187 = add <4 x i32> %173, <i32 -28, i32 -28, i32 -28, i32 -28>
%188 = mul <4 x i32> %184, %186
%189 = mul <4 x i32> %185, %187
%190 = add <4 x i32> %173, <i32 -32, i32 -32, i32 -32, i32 -32>
%191 = add i32 %174, 4
%192 = icmp eq i32 %191, %169
br i1 %192, label %193, label %170
193: ; preds = %170, %157
%194 = phi <4 x i32> [ undef, %157 ], [ %188, %170 ]
%195 = phi <4 x i32> [ undef, %157 ], [ %189, %170 ]
%196 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %157 ], [ %188, %170 ]
%197 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %157 ], [ %189, %170 ]
%198 = phi <4 x i32> [ %162, %157 ], [ %190, %170 ]
%199 = icmp eq i32 %166, 0
br i1 %199, label %211, label %200
200: ; preds = %193, %200
%201 = phi <4 x i32> [ %206, %200 ], [ %196, %193 ]
%202 = phi <4 x i32> [ %207, %200 ], [ %197, %193 ]
%203 = phi <4 x i32> [ %208, %200 ], [ %198, %193 ]
%204 = phi i32 [ %209, %200 ], [ 0, %193 ]
%205 = add <4 x i32> %203, <i32 -4, i32 -4, i32 -4, i32 -4>
%206 = mul <4 x i32> %201, %203
%207 = mul <4 x i32> %202, %205
%208 = add <4 x i32> %203, <i32 -8, i32 -8, i32 -8, i32 -8>
%209 = add i32 %204, 1
%210 = icmp eq i32 %209, %166
br i1 %210, label %211, label %200
211: ; preds = %200, %193
%212 = phi <4 x i32> [ %194, %193 ], [ %206, %200 ]
%213 = phi <4 x i32> [ %195, %193 ], [ %207, %200 ]
%214 = mul <4 x i32> %213, %212
%215 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %214)
%216 = icmp eq i32 %153, %158
br i1 %216, label %226, label %217
217: ; preds = %155, %211
%218 = phi i32 [ 1, %155 ], [ %215, %211 ]
%219 = phi i32 [ %153, %155 ], [ %159, %211 ]
br label %220
220: ; preds = %217, %220
%221 = phi i32 [ %223, %220 ], [ %218, %217 ]
%222 = phi i32 [ %224, %220 ], [ %219, %217 ]
%223 = mul nsw i32 %221, %222
%224 = add nsw i32 %222, -1
%225 = icmp ugt i32 %222, 1
br i1 %225, label %220, label %226
226: ; preds = %220, %211
%227 = phi i32 [ %215, %211 ], [ %223, %220 ]
store i32 0, i32* %5
br label %228
228: ; preds = %226, %149
%229 = phi i32 [ %227, %226 ], [ 1, %149 ]
%230 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.23, i64 0, i64 0), i32 %153, i32 %229)
br label %395
231: ; preds = %0
%232 = bitcast i32* %6 to i8*
%233 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.24, i64 0, i64 0))
%234 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %6)
%235 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%236 = load i32, i32* %6
%237 = icmp sgt i32 %236, 0
br i1 %237, label %238, label %246
238: ; preds = %231
%239 = mul i32 %236, 3
%240 = add nsw i32 %236, -1
%241 = add nsw i32 %236, -2
%242 = mul i32 %240, %241
%243 = and i32 %242, -2
%244 = add i32 %239, %243
%245 = add i32 %244, -2
br label %246
246: ; preds = %238, %231
%247 = phi i32 [ 0, %231 ], [ %245, %238 ]
%248 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.26, i64 0, i64 0), i32 %247)
br label %395
249: ; preds = %0
%250 = bitcast i32* %7 to i8*
%251 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.27, i64 0, i64 0))
%252 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %7)
%253 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%254 = load i32, i32* %7
%255 = icmp eq i32 %254, 0
br i1 %255, label %266, label %256
256: ; preds = %249, %256
%257 = phi i32 [ %261, %256 ], [ 0, %249 ]
%258 = phi i32 [ %260, %256 ], [ %254, %249 ]
%259 = srem i32 %258, 10
%260 = sdiv i32 %258, 10
%261 = add nsw i32 %257, %259
%262 = add i32 %258, 9
%263 = icmp ult i32 %262, 19
br i1 %263, label %264, label %256
264: ; preds = %256
store i32 %260, i32* %7
%265 = srem i32 %261, 10
br label %266
266: ; preds = %264, %249
%267 = phi i32 [ %265, %264 ], [ 0, %249 ]
%268 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.28, i64 0, i64 0), i32 %254, i32 %267)
br label %395
269: ; preds = %0
%270 = bitcast i32* %8 to i8*
%271 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.24, i64 0, i64 0))
%272 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %8)
%273 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%274 = load i32, i32* %8
%275 = icmp slt i32 %274, 1
br i1 %275, label %288, label %276
276: ; preds = %269
%277 = icmp eq i32 %274, 1
br i1 %277, label %282, label %278
278: ; preds = %276, %284
%279 = phi i32 [ %286, %284 ], [ 1, %276 ]
%280 = phi i32 [ %285, %284 ], [ 0, %276 ]
%281 = icmp eq i32 %274, %280
br i1 %281, label %282, label %284
282: ; preds = %278, %276
%283 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @str.58, i64 0, i64 0))
br label %288
284: ; preds = %278
%285 = add nuw nsw i32 %279, %280
%286 = add nuw i32 %279, 1
%287 = icmp eq i32 %279, %274
br i1 %287, label %288, label %278
288: ; preds = %284, %269, %282
br label %395
289: ; preds = %0
%290 = bitcast i32* %9 to i8*
%291 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.31, i64 0, i64 0))
%292 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %9)
%293 = load i32, i32* %9
br label %294
294: ; preds = %294, %289
%295 = phi i32 [ %293, %289 ], [ %306, %294 ]
%296 = phi i32 [ %293, %289 ], [ %307, %294 ]
%297 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%298 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.31, i64 0, i64 0))
%299 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32* %9)
%300 = load i32, i32* %9
%301 = icmp sle i32 %300, %296
%302 = icmp sgt i32 %300, 0
%303 = and i1 %301, %302
%304 = icmp slt i32 %300, %295
%305 = select i1 %303, i1 true, i1 %304
%306 = select i1 %305, i32 %295, i32 %300
%307 = select i1 %303, i32 %300, i32 %296
br i1 %302, label %294, label %308
308: ; preds = %294
%309 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%310 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.32, i64 0, i64 0), i32 %307)
%311 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.33, i64 0, i64 0), i32 %306)
br label %395
312: ; preds = %0
%313 = bitcast float* %10 to i8*
br label %314
314: ; preds = %314, %312
%315 = phi float [ 0.000000e+00, %312 ], [ %320, %314 ]
%316 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%317 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @.str.34, i64 0, i64 0))
%318 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), float* %10)
%319 = load float, float* %10
%320 = fadd float %315, %319
%321 = fcmp ogt float %319, 0.000000e+00
br i1 %321, label %314, label %322
322: ; preds = %314
%323 = fcmp olt float %320, 5.000000e+01
br i1 %323, label %324, label %328
324: ; preds = %322
%325 = fpext float %320 to double
%326 = fneg double %325
%327 = call double @llvm.fmuladd.f64(double %326, double 5.000000e-02, double %325)
br label %342
328: ; preds = %322
%329 = fcmp ugt float %320, 1.000000e+02
br i1 %329, label %334, label %330
330: ; preds = %328
%331 = fpext float %320 to double
%332 = fneg double %331
%333 = call double @llvm.fmuladd.f64(double %332, double 1.000000e-01, double %331)
br label %342
334: ; preds = %328
%335 = fcmp ugt float %320, 2.000000e+02
%336 = fpext float %320 to double
%337 = fneg double %336
br i1 %335, label %340, label %338
338: ; preds = %334
%339 = call double @llvm.fmuladd.f64(double %337, double 1.500000e-01, double %336)
br label %342
340: ; preds = %334
%341 = call double @llvm.fmuladd.f64(double %337, double 2.000000e-01, double %336)
br label %342
342: ; preds = %330, %340, %338, %324
%343 = phi double [ %333, %330 ], [ %341, %340 ], [ %339, %338 ], [ %327, %324 ]
%344 = fptrunc double %343 to float
%345 = fpext float %344 to double
%346 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.36, i64 0, i64 0), double %345)
br label %395
347: ; preds = %0
%348 = bitcast float* %11 to i8*
%349 = bitcast float* %12 to i8*
%350 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.37, i64 0, i64 0))
%351 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), float* %11)
br label %352
352: ; preds = %374, %347
%353 = phi float [ 0.000000e+00, %347 ], [ %376, %374 ]
%354 = phi float [ 0.000000e+00, %347 ], [ %377, %374 ]
%355 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%356 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([81 x i8], [81 x i8]* @.str.38, i64 0, i64 0))
%357 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.39, i64 0, i64 0), i8* %13)
%358 = load i8, i8* %13
%359 = sext i8 %358 to i32
switch i32 %359, label %374 [
i32 43, label %360
i32 45, label %365
]
360: ; preds = %352
%361 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.40, i64 0, i64 0))
%362 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), float* %12)
%363 = load float, float* %12
%364 = fadd float %353, %363
br label %370
365: ; preds = %352
%366 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.40, i64 0, i64 0))
%367 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), float* %12)
%368 = load float, float* %12
%369 = fadd float %354, %368
br label %370
370: ; preds = %365, %360
%371 = phi float [ %364, %360 ], [ %353, %365 ]
%372 = phi float [ %354, %360 ], [ %369, %365 ]
%373 = load i8, i8* %13
br label %374
374: ; preds = %370, %352
%375 = phi i8 [ %373, %370 ], [ %358, %352 ]
%376 = phi float [ %371, %370 ], [ %353, %352 ]
%377 = phi float [ %372, %370 ], [ %354, %352 ]
%378 = icmp eq i8 %375, 48
br i1 %378, label %379, label %352
379: ; preds = %374
%380 = call i32 @system(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%381 = fpext float %377 to double
%382 = fmul double %381, 3.500000e-03
%383 = fptrunc double %382 to float
%384 = load float, float* %11
%385 = fsub float %384, %377
%386 = fadd float %376, %385
%387 = fsub float %386, %383
%388 = fpext float %376 to double
%389 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.41, i64 0, i64 0), double %388)
%390 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.42, i64 0, i64 0), double %381)
%391 = fpext float %383 to double
%392 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.43, i64 0, i64 0), double %391)
%393 = fpext float %387 to double
%394 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.44, i64 0, i64 0), double %393)
br label %395
395: ; preds = %33, %0, %379, %342, %308, %288, %266, %246, %228, %146, %68
ret i32 0
}