void ex3() {
  print("\n------------------------------\n");
  print("3. Escrever as seguintes expressoes algebricas como expressoes "
        "aritmeticas na Linguagem C.\nTeste no computador se suas expressoes "
        "estao escritas corretamente, fornecendo os valores das variaveis "
        "usadas na expressao.\nConfira o resultado do computador com aquele "
        "calculado usando a calculadora.");
  float x = rand() % 5 + 1, i = rand() % 5 + 1, j = rand() % 5 + 1;
  float resultA = pow(x, i + j);
  print("\nLetra A:");
  printf("\tValores:\n\t\tx=%.2f\n\t\ti=%.2f\n\t\tj=%.2f\n", x, i, j);
  print("\tOperacao A: x ^ (i + j)");
  printf("\tResultado: %.2f\n", resultA);
  float a = rand() % 5 + 1, b = rand() % 5 + 1, c = rand() % 5 + 1;
  float resultB = (a + b) * (2 - ((pow(c, 2) / (1 - (pow(c, 3))))));
  print("\nLetra B:");
  printf("\tValores:\n\t\ta=%.2f\n\t\tb=%.2f\n\t\tc=%.2f\n", a, b, c);
  print("\tOperacao B: (a + b) * [ 2 - ( c^2 / [1 - c^3] ) ]");
  printf("\tResultado: %.6f\n", resultB);
  float y = rand() % 5 + 1;
  float resultC = 2 / (2 - (5 * y));
  print("\nLetra C:");
  printf("\tValores:\n\t\ty=%.2f\n", y);
  print("\tOperacao C: 2 / (2 - (5 * y))");
  printf("\tResultado: %.6f\n", resultC);
  float A = rand() % 5 + 1, B = rand() % 5 + 1, C = rand() % 5 + 1,
        D = rand() % 5 + 1;
  float resultD = A + (B / (C + D));
  print("\nLetra D:");
  printf("\tValores:\n\t\tA=%.2f\n\t\tB=%.2f\n\t\tC=%.2f\n\t\tD=%.2f\n", A, B,
         C, D);
  print("\tOperacao D: A + (B / (C + D))");
  printf("\tResultado: %.6f\n", resultD);
  float r = rand() % 5 + 1, s = rand() % 5 + 1, t = rand() % 5 + 1;
  float resultE = 1 / ((1 / r) + (1 / s) + (1 / t));
  print("\nLetra E:");
  printf("\tValores:\n\t\tr=%.2f\n\t\ts=%.2f\n\t\tt=%.2f\n", r, s, t);
  print("\tOperacao E: 1 / ((1/r) + (1/s) + (1/t))");
  printf("\tResultado: %.6f\n", resultE);
  float m = rand() % 5 + 1, n = rand() % 5 + 1;
  float resultF = 20 / (m + n);
  print("\nLetra F:");
  printf("\tValores:\n\t\tm=%.2f\n\t\tn=%.2f\n", m, n);
  print("\tOperacao A: 20 / (m + n)");
  printf("\tResultado: %.4f\n", resultF);
  print("\nLetra G: Repetida (letra B)");
  float p = rand() % 5 + 1, w = rand() % 5 + 1, u = rand() % 5 + 1,
        v = rand() % 5 + 1;
  while (v == u) {
    v = rand() % 5 + 1;
  }
  float resultH = (p + (w / (u + v))) / (p - (w / (u - v)));
  print("\nLetra H:");
  printf("\tValores:\n\t\tp=%.2f\n\t\tw=%.2f\n\t\tu=%.2f\n\t\tv=%.2f\n", p, w,
         u, v);
  print("\tOperacao H: (p + (w / (u + v))) / (p - (w / (u - v)))");
  printf("\tResultado: %.4f\n", resultH);
  float _a = rand() % 5 + 1, _b = rand() % 5 + 1, _c = rand() % 5 + 1,
        _d = rand() % 5 + 1;
  float resultI = _a / (_b + (_c / _d));
  print("\nLetra I:");
  printf("\tValores:\n\t\t_a=%.2f\n\t\t_b=%.2f\n\t\t_c=%.2f\n\t\t_d=%.2f\n", _a,
         _b, _c, _d);
  print("\tOperacao I: _a / (_b + (_c / _d))");
  printf("\tResultado: %.6f\n", resultI);
  float N = rand() % 5 + 1;
  float resultJ = pow(1 + (1 / N), N);
  print("\nLetra J:");
  printf("\tValores:\n\t\tN=%.2f\n", N);
  print("\tOperacao J: (1 + (1 / N)) ^ N");
  printf("\tResultado: %.6f\n", resultJ);
  float X = rand() % 5 + 1, Y = rand() % 5 + 1;
  float resultK = 0.5 * (sqrt(pow(X, 2) + pow(Y, 2)));
  print("\nLetra K:");
  printf("\tValores:\n\t\tX=%.2f\n\t\tY=%.2f\n", X, Y);
  print("\tOperacao K: 0.5 * (sqrt(X^2 + Y^2))");
  printf("\tResultado: %.6f\n", resultK);
  float _A = rand() % 5 + 1, _B = rand() % 5 + 1, _C = rand() % 5 + 1;
  float resultL = sqrt(_A + _B) / (pow(_C, 2) - (2 * _A));
  print("\nLetra L:");
  printf("\tValores:\n\t\t_A=%.2f\n\t\t_B=%.2f\n\t\t_C=%.2f\n", _A, _B, _C);
  print("\tOperacao L: sqrt(_A + _B) / (_C^2 - (2 * _A))");
  printf("\tResultado: %.6f\n", resultL);
  float _x = rand() % 5 + 1, _y = rand() % 5 + 1, g = rand() % 5 + 1;
  float resultM = pow(_x / _y, g - 1);
  print("\nLetra M:");
  printf("\tValores:\n\t\t_x=%.2f\n\t\t_y=%.2f\n\t\tg=%.2f\n", _x, _y, g);
  print("\tOperacao M: (_x / _y) ^ (g - 1)");
  printf("\tResultado: %.6f\n", resultM);
  print("\n------------------------------\n");
}


x86 assembly (clang, -O0):
<ex3>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
lea    0xece(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
lea    0xee1(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x4(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x8(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x8(%rbp),%xmm1
addss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
call   1050 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
lea    0xf82(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x8(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0xc(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xf63(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
lea    0xf7b(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xf7d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x14(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x14(%rbp),%xmm0
addss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd4f(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd41(%rip),%xmm1
call   1050 <pow@plt>
movsd  -0xc8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0xd19(%rip),%xmm1
subsd  %xmm3,%xmm1
divsd  %xmm1,%xmm2
movsd  0xd01(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
lea    0xeaa(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x1c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xe8b(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
lea    0xea3(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xebf(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm1
movss  0xc68(%rip),%xmm0
mulss  %xmm0,%xmm1
movss  0xc58(%rip),%xmm0
addss  %xmm0,%xmm1
movss  0xc4c(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
lea    0xe7a(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe6d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xe73(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe2c(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm1
movss  -0x34(%rbp),%xmm2
addss  -0x38(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
lea    0xde0(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x30(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x34(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x38(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xdb8(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0xdd9(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd3a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xaaa(%rip),%xmm1
divss  -0x40(%rbp),%xmm1
movss  0xa9d(%rip),%xmm0
divss  -0x44(%rbp),%xmm0
addss  %xmm0,%xmm1
movss  0xa8c(%rip),%xmm0
divss  -0x48(%rbp),%xmm0
addss  %xmm0,%xmm1
movss  0xa7b(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
lea    0xd42(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x48(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xd23(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
lea    0xd3b(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc4d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x50(%rbp),%xmm1
addss  -0x54(%rbp),%xmm1
movss  0x9ca(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
lea    0xcee(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x54(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xcd8(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
lea    0xce7(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcea(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xcee(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
ucomiss -0x64(%rbp),%xmm0
jne    1741 <ex3+0x5f1>
jp     1741 <ex3+0x5f1>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x68(%rbp)
jmp    170c <ex3+0x5bc>
movss  -0x5c(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
addss  -0x68(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm2
movss  -0x64(%rbp),%xmm3
subss  -0x68(%rbp),%xmm3
divss  %xmm3,%xmm2
subss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
lea    0xc1b(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x64(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x68(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xbf3(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0xc14(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb95(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x74(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
divss  -0x7c(%rbp),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
lea    0xb99(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x78(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x7c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xb71(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0xb96(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x962(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  0x705(%rip),%xmm1
divss  -0x84(%rbp),%xmm1
ff
movss  0x6f5(%rip),%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x84(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
call   1050 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
lea    0xb39(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb29(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xb2f(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x88(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x8b7(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x63c(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x61b(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x60f(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
lea    0xa81(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x90(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0xa65(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
lea    0xa74(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x7b6(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x4fc(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movss  0x4dc(%rip),%xmm2
mulss  -0x98(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
lea    0x9aa(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x9c(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0xa0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
lea    0x982(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
lea    0x99d(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x687(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2ss %edx,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
divss  -0xac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0xb0(%rbp),%xmm1
ff
movss  0x3d2(%rip),%xmm2
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
call   1050 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
lea    0x90d(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0xac(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0xb0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
lea    0x8e5(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
lea    0x8ff(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
movss  -0xb4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x588(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x376(%rip),%rdi
mov    $0x0,%al
call   1040 <print@plt>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ex3>:
push   %rbp
push   %rbx
sub    $0x38,%rsp
lea    0xf03(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
lea    0xf16(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm2
movss  %xmm2,0x18(%rsp)
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
movss  0x8(%rsp),%xmm1
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
call   1050 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
lea    0xf6a(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movss  0x18(%rsp),%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
lea    0xf4c(%rip),%rdi
movsd  0x20(%rsp),%xmm0
mov    $0x3,%al
call   1030 <printf@plt>
lea    0xf5e(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xf5f(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0x8(%rsp),%xmm1
addss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x18(%rsp)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
movaps %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0xc9e(%rip),%xmm1
call   1050 <pow@plt>
movsd  0xc99(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0x30(%rsp),%xmm2
divsd  %xmm1,%xmm2
movsd  0xc8b(%rip),%xmm0
subsd  %xmm2,%xmm0
mulsd  0x18(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x18(%rsp)
lea    0xe61(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xe49(%rip),%rdi
movsd  0x20(%rsp),%xmm2
mov    $0x3,%al
call   1030 <printf@plt>
lea    0xe5b(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe76(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  %xmm1,0x10(%rsp)
movss  0xbf4(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  0xbec(%rip),%xmm1
addss  %xmm1,%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%rsp)
lea    0xe21(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe13(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xe19(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x20(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm1
movss  %xmm1,0x30(%rsp)
movss  0x20(%rsp),%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rsp),%xmm1
divss  %xmm0,%xmm1
addss  0x8(%rsp),%xmm1
movss  %xmm1,0x18(%rsp)
lea    0xd29(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x20(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x30(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xcfd(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0xd1e(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
movd   %ebp,%xmm1
movd   %eax,%xmm2
movdqa %xmm1,%xmm0
punpckldq %xmm2,%xmm0
movdqa 0x9fb(%rip),%xmm3
pmuludq %xmm3,%xmm1
pshufd $0xed,%xmm1,%xmm1
pmuludq %xmm3,%xmm2
pshufd $0xed,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
pxor   %xmm2,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm3,%xmm2
psubd  %xmm2,%xmm1
movdqa %xmm1,%xmm2
psrld  $0x1f,%xmm2
psrad  $0x1,%xmm1
paddd  %xmm2,%xmm1
movdqa %xmm1,%xmm2
pslld  $0x2,%xmm2
paddd  %xmm1,%xmm2
psubd  %xmm2,%xmm0
pcmpeqd %xmm1,%xmm1
psubd  %xmm1,%xmm0
cvtdq2ps %xmm0,%xmm3
movaps %xmm3,0x20(%rsp)
movss  0x98a(%rip),%xmm2
movaps %xmm2,%xmm0
divss  0x8(%rsp),%xmm0
movaps 0x99a(%rip),%xmm1
divps  %xmm3,%xmm1
addss  %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm1
addss  %xmm0,%xmm1
divss  %xmm1,%xmm2
movss  %xmm2,0x10(%rsp)
lea    0xc35(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movaps 0x20(%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
movss  0x8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
shufps $0x55,%xmm2,%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xc13(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
lea    0xc2b(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  %xmm1,0x20(%rsp)
movss  0x8(%rsp),%xmm0
addss  %xmm1,%xmm0
movss  0x88f(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x10(%rsp)
lea    0xbae(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x20(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xb96(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
lea    0xba5(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xba7(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xbab(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x20(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
nop
xor    %eax,%eax
call   1070 <rand@plt>
movss  0x8(%rsp),%xmm1
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
ucomiss %xmm1,%xmm0
jne    18eb <ex3+0x79b>
jnp    18b0 <ex3+0x760>
movaps %xmm0,%xmm3
movss  %xmm0,0x30(%rsp)
addss  %xmm1,%xmm0
movss  0x20(%rsp),%xmm4
movaps %xmm4,%xmm2
divss  %xmm0,%xmm2
movss  0x10(%rsp),%xmm5
addss  %xmm5,%xmm2
movaps %xmm1,%xmm0
subss  %xmm3,%xmm0
movaps %xmm4,%xmm1
divss  %xmm0,%xmm1
movaps %xmm5,%xmm0
subss  %xmm1,%xmm0
divss  %xmm0,%xmm2
movss  %xmm2,0x18(%rsp)
lea    0xa9f(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x20(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x8(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x30(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xa73(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0xa94(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa14(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x20(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm1
movss  %xmm1,0x30(%rsp)
movss  0x20(%rsp),%xmm0
divss  %xmm1,%xmm0
addss  0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x18(%rsp)
lea    0x9b8(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x20(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x30(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0x98c(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
lea    0x9b1(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x77c(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  0x508(%rip),%xmm2
movaps %xmm2,%xmm0
divss  %xmm1,%xmm0
addss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x10(%rsp)
call   1050 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
lea    0x94d(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
lea    0x949(%rip),%rdi
movsd  0x10(%rsp),%xmm0
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x949(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0x8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c2c <ex3+0xadc>
sqrtsd %xmm0,%xmm0
jmp    1c31 <ex3+0xae1>
call   1060 <sqrt@plt>
mulsd  0x3df(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x20(%rsp)
lea    0x897(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
lea    0x893(%rip),%rdi
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mov    $0x2,%al
call   1030 <printf@plt>
lea    0x896(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x5da(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  0x8(%rsp),%xmm0
addss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd 0x2e1(%rip),%xmm0
jb     1d47 <ex3+0xbf7>
sqrtsd %xmm0,%xmm0
jmp    1d58 <ex3+0xc08>
movss  %xmm1,0x20(%rsp)
call   1060 <sqrt@plt>
movss  0x20(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x18(%rsp)
mulsd  %xmm1,%xmm1
movss  0x8(%rsp),%xmm2
addss  %xmm2,%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x20(%rsp)
lea    0x7a0(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x788(%rip),%rdi
movsd  0x18(%rsp),%xmm2
mov    $0x3,%al
call   1030 <printf@plt>
lea    0x79d(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x489(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
movss  %xmm2,0x18(%rsp)
movss  0x8(%rsp),%xmm0
divss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x19f(%rip),%xmm1
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
call   1050 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x20(%rsp)
lea    0x6d8(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x18(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0x6b6(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
lea    0x6d0(%rip),%rdi
xor    %eax,%eax
call   1040 <print@plt>
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x14d(%rip),%rdi
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %rbp
jmp    1040 <print@plt>

LLVM IR (-O0):
@.str = [33 x i8] c"\0A------------------------------\0A\00"
@.str.1 = [293 x i8] c"3. Escrever as seguintes expressoes algebricas como expressoes aritmeticas na Linguagem C.\0ATeste no computador se suas expressoes estao escritas corretamente, fornecendo os valores das variaveis usadas na expressao.\0AConfira o resultado do computador com aquele calculado usando a calculadora.\00"
@.str.2 = [10 x i8] c"\0ALetra A:\00"
@.str.3 = [38 x i8] c"\09Valores:\0A\09\09x=%.2f\0A\09\09i=%.2f\0A\09\09j=%.2f\0A\00"
@.str.4 = [25 x i8] c"\09Operacao A: x ^ (i + j)\00"
@.str.5 = [18 x i8] c"\09Resultado: %.2f\0A\00"
@.str.6 = [10 x i8] c"\0ALetra B:\00"
@.str.7 = [38 x i8] c"\09Valores:\0A\09\09a=%.2f\0A\09\09b=%.2f\0A\09\09c=%.2f\0A\00"
@.str.8 = [51 x i8] c"\09Operacao B: (a + b) * [ 2 - ( c^2 / [1 - c^3] ) ]\00"
@.str.9 = [18 x i8] c"\09Resultado: %.6f\0A\00"
@.str.10 = [10 x i8] c"\0ALetra C:\00"
@.str.11 = [20 x i8] c"\09Valores:\0A\09\09y=%.2f\0A\00"
@.str.12 = [31 x i8] c"\09Operacao C: 2 / (2 - (5 * y))\00"
@.str.13 = [10 x i8] c"\0ALetra D:\00"
@.str.14 = [47 x i8] c"\09Valores:\0A\09\09A=%.2f\0A\09\09B=%.2f\0A\09\09C=%.2f\0A\09\09D=%.2f\0A\00"
@.str.15 = [31 x i8] c"\09Operacao D: A + (B / (C + D))\00"
@.str.16 = [10 x i8] c"\0ALetra E:\00"
@.str.17 = [38 x i8] c"\09Valores:\0A\09\09r=%.2f\0A\09\09s=%.2f\0A\09\09t=%.2f\0A\00"
@.str.18 = [41 x i8] c"\09Operacao E: 1 / ((1/r) + (1/s) + (1/t))\00"
@.str.19 = [10 x i8] c"\0ALetra F:\00"
@.str.20 = [29 x i8] c"\09Valores:\0A\09\09m=%.2f\0A\09\09n=%.2f\0A\00"
@.str.21 = [26 x i8] c"\09Operacao A: 20 / (m + n)\00"
@.str.22 = [18 x i8] c"\09Resultado: %.4f\0A\00"
@.str.23 = [29 x i8] c"\0ALetra G: Repetida (letra B)\00"
@.str.24 = [10 x i8] c"\0ALetra H:\00"
@.str.25 = [47 x i8] c"\09Valores:\0A\09\09p=%.2f\0A\09\09w=%.2f\0A\09\09u=%.2f\0A\09\09v=%.2f\0A\00"
@.str.26 = [55 x i8] c"\09Operacao H: (p + (w / (u + v))) / (p - (w / (u - v)))\00"
@.str.27 = [10 x i8] c"\0ALetra I:\00"
@.str.28 = [51 x i8] c"\09Valores:\0A\09\09_a=%.2f\0A\09\09_b=%.2f\0A\09\09_c=%.2f\0A\09\09_d=%.2f\0A\00"
@.str.29 = [35 x i8] c"\09Operacao I: _a / (_b + (_c / _d))\00"
@.str.30 = [10 x i8] c"\0ALetra J:\00"
@.str.31 = [20 x i8] c"\09Valores:\0A\09\09N=%.2f\0A\00"
@.str.32 = [31 x i8] c"\09Operacao J: (1 + (1 / N)) ^ N\00"
@.str.33 = [10 x i8] c"\0ALetra K:\00"
@.str.34 = [29 x i8] c"\09Valores:\0A\09\09X=%.2f\0A\09\09Y=%.2f\0A\00"
@.str.35 = [37 x i8] c"\09Operacao K: 0.5 * (sqrt(X^2 + Y^2))\00"
@.str.36 = [10 x i8] c"\0ALetra L:\00"
@.str.37 = [41 x i8] c"\09Valores:\0A\09\09_A=%.2f\0A\09\09_B=%.2f\0A\09\09_C=%.2f\0A\00"
@.str.38 = [47 x i8] c"\09Operacao L: sqrt(_A + _B) / (_C^2 - (2 * _A))\00"
@.str.39 = [10 x i8] c"\0ALetra M:\00"
@.str.40 = [40 x i8] c"\09Valores:\0A\09\09_x=%.2f\0A\09\09_y=%.2f\0A\09\09g=%.2f\0A\00"
@.str.41 = [33 x i8] c"\09Operacao M: (_x / _y) ^ (g - 1)\00"
define void @ex3() {
%1 = alloca float
%2 = alloca float
%3 = alloca float
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%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 float
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%47 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([293 x i8], [293 x i8]* @.str.1, i64 0, i64 0))
%48 = call i32 (...) @rand()
%49 = srem i32 %48, 5
%50 = add nsw i32 %49, 1
%51 = sitofp i32 %50 to float
store float %51, float* %1
%52 = call i32 (...) @rand()
%53 = srem i32 %52, 5
%54 = add nsw i32 %53, 1
%55 = sitofp i32 %54 to float
store float %55, float* %2
%56 = call i32 (...) @rand()
%57 = srem i32 %56, 5
%58 = add nsw i32 %57, 1
%59 = sitofp i32 %58 to float
store float %59, float* %3
%60 = load float, float* %1
%61 = fpext float %60 to double
%62 = load float, float* %2
%63 = load float, float* %3
%64 = fadd float %62, %63
%65 = fpext float %64 to double
%66 = call double @pow(double %61, double %65)
%67 = fptrunc double %66 to float
store float %67, float* %4
%68 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%69 = load float, float* %1
%70 = fpext float %69 to double
%71 = load float, float* %2
%72 = fpext float %71 to double
%73 = load float, float* %3
%74 = fpext float %73 to double
%75 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.3, i64 0, i64 0), double %70, double %72, double %74)
%76 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.4, i64 0, i64 0))
%77 = load float, float* %4
%78 = fpext float %77 to double
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), double %78)
%80 = call i32 (...) @rand()
%81 = srem i32 %80, 5
%82 = add nsw i32 %81, 1
%83 = sitofp i32 %82 to float
store float %83, float* %5
%84 = call i32 (...) @rand()
%85 = srem i32 %84, 5
%86 = add nsw i32 %85, 1
%87 = sitofp i32 %86 to float
store float %87, float* %6
%88 = call i32 (...) @rand()
%89 = srem i32 %88, 5
%90 = add nsw i32 %89, 1
%91 = sitofp i32 %90 to float
store float %91, float* %7
%92 = load float, float* %5
%93 = load float, float* %6
%94 = fadd float %92, %93
%95 = fpext float %94 to double
%96 = load float, float* %7
%97 = fpext float %96 to double
%98 = call double @pow(double %97, double 2.000000e+00)
%99 = load float, float* %7
%100 = fpext float %99 to double
%101 = call double @pow(double %100, double 3.000000e+00)
%102 = fsub double 1.000000e+00, %101
%103 = fdiv double %98, %102
%104 = fsub double 2.000000e+00, %103
%105 = fmul double %95, %104
%106 = fptrunc double %105 to float
store float %106, float* %8
%107 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%108 = load float, float* %5
%109 = fpext float %108 to double
%110 = load float, float* %6
%111 = fpext float %110 to double
%112 = load float, float* %7
%113 = fpext float %112 to double
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.7, i64 0, i64 0), double %109, double %111, double %113)
%115 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.8, i64 0, i64 0))
%116 = load float, float* %8
%117 = fpext float %116 to double
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %117)
%119 = call i32 (...) @rand()
%120 = srem i32 %119, 5
%121 = add nsw i32 %120, 1
%122 = sitofp i32 %121 to float
store float %122, float* %9
%123 = load float, float* %9
%124 = call float @llvm.fmuladd.f32(float -5.000000e+00, float %123, float 2.000000e+00)
%125 = fdiv float 2.000000e+00, %124
store float %125, float* %10
%126 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
%127 = load float, float* %9
%128 = fpext float %127 to double
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.11, i64 0, i64 0), double %128)
%130 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.12, i64 0, i64 0))
%131 = load float, float* %10
%132 = fpext float %131 to double
%133 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %132)
%134 = call i32 (...) @rand()
%135 = srem i32 %134, 5
%136 = add nsw i32 %135, 1
%137 = sitofp i32 %136 to float
store float %137, float* %11
%138 = call i32 (...) @rand()
%139 = srem i32 %138, 5
%140 = add nsw i32 %139, 1
%141 = sitofp i32 %140 to float
store float %141, float* %12
%142 = call i32 (...) @rand()
%143 = srem i32 %142, 5
%144 = add nsw i32 %143, 1
%145 = sitofp i32 %144 to float
store float %145, float* %13
%146 = call i32 (...) @rand()
%147 = srem i32 %146, 5
%148 = add nsw i32 %147, 1
%149 = sitofp i32 %148 to float
store float %149, float* %14
%150 = load float, float* %11
%151 = load float, float* %12
%152 = load float, float* %13
%153 = load float, float* %14
%154 = fadd float %152, %153
%155 = fdiv float %151, %154
%156 = fadd float %150, %155
store float %156, float* %15
%157 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%158 = load float, float* %11
%159 = fpext float %158 to double
%160 = load float, float* %12
%161 = fpext float %160 to double
%162 = load float, float* %13
%163 = fpext float %162 to double
%164 = load float, float* %14
%165 = fpext float %164 to double
%166 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.14, i64 0, i64 0), double %159, double %161, double %163, double %165)
%167 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.15, i64 0, i64 0))
%168 = load float, float* %15
%169 = fpext float %168 to double
%170 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %169)
%171 = call i32 (...) @rand()
%172 = srem i32 %171, 5
%173 = add nsw i32 %172, 1
%174 = sitofp i32 %173 to float
store float %174, float* %16
%175 = call i32 (...) @rand()
%176 = srem i32 %175, 5
%177 = add nsw i32 %176, 1
%178 = sitofp i32 %177 to float
store float %178, float* %17
%179 = call i32 (...) @rand()
%180 = srem i32 %179, 5
%181 = add nsw i32 %180, 1
%182 = sitofp i32 %181 to float
store float %182, float* %18
%183 = load float, float* %16
%184 = fdiv float 1.000000e+00, %183
%185 = load float, float* %17
%186 = fdiv float 1.000000e+00, %185
%187 = fadd float %184, %186
%188 = load float, float* %18
%189 = fdiv float 1.000000e+00, %188
%190 = fadd float %187, %189
%191 = fdiv float 1.000000e+00, %190
store float %191, float* %19
%192 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.16, i64 0, i64 0))
%193 = load float, float* %16
%194 = fpext float %193 to double
%195 = load float, float* %17
%196 = fpext float %195 to double
%197 = load float, float* %18
%198 = fpext float %197 to double
%199 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.17, i64 0, i64 0), double %194, double %196, double %198)
%200 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.18, i64 0, i64 0))
%201 = load float, float* %19
%202 = fpext float %201 to double
%203 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %202)
%204 = call i32 (...) @rand()
%205 = srem i32 %204, 5
%206 = add nsw i32 %205, 1
%207 = sitofp i32 %206 to float
store float %207, float* %20
%208 = call i32 (...) @rand()
%209 = srem i32 %208, 5
%210 = add nsw i32 %209, 1
%211 = sitofp i32 %210 to float
store float %211, float* %21
%212 = load float, float* %20
%213 = load float, float* %21
%214 = fadd float %212, %213
%215 = fdiv float 2.000000e+01, %214
store float %215, float* %22
%216 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.19, i64 0, i64 0))
%217 = load float, float* %20
%218 = fpext float %217 to double
%219 = load float, float* %21
%220 = fpext float %219 to double
%221 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.20, i64 0, i64 0), double %218, double %220)
%222 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.21, i64 0, i64 0))
%223 = load float, float* %22
%224 = fpext float %223 to double
%225 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.22, i64 0, i64 0), double %224)
%226 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.23, i64 0, i64 0))
%227 = call i32 (...) @rand()
%228 = srem i32 %227, 5
%229 = add nsw i32 %228, 1
%230 = sitofp i32 %229 to float
store float %230, float* %23
%231 = call i32 (...) @rand()
%232 = srem i32 %231, 5
%233 = add nsw i32 %232, 1
%234 = sitofp i32 %233 to float
store float %234, float* %24
%235 = call i32 (...) @rand()
%236 = srem i32 %235, 5
%237 = add nsw i32 %236, 1
%238 = sitofp i32 %237 to float
store float %238, float* %25
%239 = call i32 (...) @rand()
%240 = srem i32 %239, 5
%241 = add nsw i32 %240, 1
%242 = sitofp i32 %241 to float
store float %242, float* %26
br label %243
243: ; preds = %247, %0
%244 = load float, float* %26
%245 = load float, float* %25
%246 = fcmp oeq float %244, %245
br i1 %246, label %247, label %252
247: ; preds = %243
%248 = call i32 (...) @rand()
%249 = srem i32 %248, 5
%250 = add nsw i32 %249, 1
%251 = sitofp i32 %250 to float
store float %251, float* %26
br label %243
252: ; preds = %243
%253 = load float, float* %23
%254 = load float, float* %24
%255 = load float, float* %25
%256 = load float, float* %26
%257 = fadd float %255, %256
%258 = fdiv float %254, %257
%259 = fadd float %253, %258
%260 = load float, float* %23
%261 = load float, float* %24
%262 = load float, float* %25
%263 = load float, float* %26
%264 = fsub float %262, %263
%265 = fdiv float %261, %264
%266 = fsub float %260, %265
%267 = fdiv float %259, %266
store float %267, float* %27
%268 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.24, i64 0, i64 0))
%269 = load float, float* %23
%270 = fpext float %269 to double
%271 = load float, float* %24
%272 = fpext float %271 to double
%273 = load float, float* %25
%274 = fpext float %273 to double
%275 = load float, float* %26
%276 = fpext float %275 to double
%277 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.25, i64 0, i64 0), double %270, double %272, double %274, double %276)
%278 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.26, i64 0, i64 0))
%279 = load float, float* %27
%280 = fpext float %279 to double
%281 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.22, i64 0, i64 0), double %280)
%282 = call i32 (...) @rand()
%283 = srem i32 %282, 5
%284 = add nsw i32 %283, 1
%285 = sitofp i32 %284 to float
store float %285, float* %28
%286 = call i32 (...) @rand()
%287 = srem i32 %286, 5
%288 = add nsw i32 %287, 1
%289 = sitofp i32 %288 to float
store float %289, float* %29
%290 = call i32 (...) @rand()
%291 = srem i32 %290, 5
%292 = add nsw i32 %291, 1
%293 = sitofp i32 %292 to float
store float %293, float* %30
%294 = call i32 (...) @rand()
%295 = srem i32 %294, 5
%296 = add nsw i32 %295, 1
%297 = sitofp i32 %296 to float
store float %297, float* %31
%298 = load float, float* %28
%299 = load float, float* %29
%300 = load float, float* %30
%301 = load float, float* %31
%302 = fdiv float %300, %301
%303 = fadd float %299, %302
%304 = fdiv float %298, %303
store float %304, float* %32
%305 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.27, i64 0, i64 0))
%306 = load float, float* %28
%307 = fpext float %306 to double
%308 = load float, float* %29
%309 = fpext float %308 to double
%310 = load float, float* %30
%311 = fpext float %310 to double
%312 = load float, float* %31
%313 = fpext float %312 to double
%314 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.28, i64 0, i64 0), double %307, double %309, double %311, double %313)
%315 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.29, i64 0, i64 0))
%316 = load float, float* %32
%317 = fpext float %316 to double
%318 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %317)
%319 = call i32 (...) @rand()
%320 = srem i32 %319, 5
%321 = add nsw i32 %320, 1
%322 = sitofp i32 %321 to float
store float %322, float* %33
%323 = load float, float* %33
%324 = fdiv float 1.000000e+00, %323
%325 = fadd float 1.000000e+00, %324
%326 = fpext float %325 to double
%327 = load float, float* %33
%328 = fpext float %327 to double
%329 = call double @pow(double %326, double %328)
%330 = fptrunc double %329 to float
store float %330, float* %34
%331 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.30, i64 0, i64 0))
%332 = load float, float* %33
%333 = fpext float %332 to double
%334 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.31, i64 0, i64 0), double %333)
%335 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.32, i64 0, i64 0))
%336 = load float, float* %34
%337 = fpext float %336 to double
%338 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %337)
%339 = call i32 (...) @rand()
%340 = srem i32 %339, 5
%341 = add nsw i32 %340, 1
%342 = sitofp i32 %341 to float
store float %342, float* %35
%343 = call i32 (...) @rand()
%344 = srem i32 %343, 5
%345 = add nsw i32 %344, 1
%346 = sitofp i32 %345 to float
store float %346, float* %36
%347 = load float, float* %35
%348 = fpext float %347 to double
%349 = call double @pow(double %348, double 2.000000e+00)
%350 = load float, float* %36
%351 = fpext float %350 to double
%352 = call double @pow(double %351, double 2.000000e+00)
%353 = fadd double %349, %352
%354 = call double @sqrt(double %353)
%355 = fmul double 5.000000e-01, %354
%356 = fptrunc double %355 to float
store float %356, float* %37
%357 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.33, i64 0, i64 0))
%358 = load float, float* %35
%359 = fpext float %358 to double
%360 = load float, float* %36
%361 = fpext float %360 to double
%362 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.34, i64 0, i64 0), double %359, double %361)
%363 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.35, i64 0, i64 0))
%364 = load float, float* %37
%365 = fpext float %364 to double
%366 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %365)
%367 = call i32 (...) @rand()
%368 = srem i32 %367, 5
%369 = add nsw i32 %368, 1
%370 = sitofp i32 %369 to float
store float %370, float* %38
%371 = call i32 (...) @rand()
%372 = srem i32 %371, 5
%373 = add nsw i32 %372, 1
%374 = sitofp i32 %373 to float
store float %374, float* %39
%375 = call i32 (...) @rand()
%376 = srem i32 %375, 5
%377 = add nsw i32 %376, 1
%378 = sitofp i32 %377 to float
store float %378, float* %40
%379 = load float, float* %38
%380 = load float, float* %39
%381 = fadd float %379, %380
%382 = fpext float %381 to double
%383 = call double @sqrt(double %382)
%384 = load float, float* %40
%385 = fpext float %384 to double
%386 = call double @pow(double %385, double 2.000000e+00)
%387 = load float, float* %38
%388 = fmul float 2.000000e+00, %387
%389 = fpext float %388 to double
%390 = fsub double %386, %389
%391 = fdiv double %383, %390
%392 = fptrunc double %391 to float
store float %392, float* %41
%393 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.36, i64 0, i64 0))
%394 = load float, float* %38
%395 = fpext float %394 to double
%396 = load float, float* %39
%397 = fpext float %396 to double
%398 = load float, float* %40
%399 = fpext float %398 to double
%400 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.37, i64 0, i64 0), double %395, double %397, double %399)
%401 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.38, i64 0, i64 0))
%402 = load float, float* %41
%403 = fpext float %402 to double
%404 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %403)
%405 = call i32 (...) @rand()
%406 = srem i32 %405, 5
%407 = add nsw i32 %406, 1
%408 = sitofp i32 %407 to float
store float %408, float* %42
%409 = call i32 (...) @rand()
%410 = srem i32 %409, 5
%411 = add nsw i32 %410, 1
%412 = sitofp i32 %411 to float
store float %412, float* %43
%413 = call i32 (...) @rand()
%414 = srem i32 %413, 5
%415 = add nsw i32 %414, 1
%416 = sitofp i32 %415 to float
store float %416, float* %44
%417 = load float, float* %42
%418 = load float, float* %43
%419 = fdiv float %417, %418
%420 = fpext float %419 to double
%421 = load float, float* %44
%422 = fsub float %421, 1.000000e+00
%423 = fpext float %422 to double
%424 = call double @pow(double %420, double %423)
%425 = fptrunc double %424 to float
store float %425, float* %45
%426 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.39, i64 0, i64 0))
%427 = load float, float* %42
%428 = fpext float %427 to double
%429 = load float, float* %43
%430 = fpext float %429 to double
%431 = load float, float* %44
%432 = fpext float %431 to double
%433 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.40, i64 0, i64 0), double %428, double %430, double %432)
%434 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.41, i64 0, i64 0))
%435 = load float, float* %45
%436 = fpext float %435 to double
%437 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %436)
%438 = call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [33 x i8] c"\0A------------------------------\0A\00"
@.str.1 = [293 x i8] c"3. Escrever as seguintes expressoes algebricas como expressoes aritmeticas na Linguagem C.\0ATeste no computador se suas expressoes estao escritas corretamente, fornecendo os valores das variaveis usadas na expressao.\0AConfira o resultado do computador com aquele calculado usando a calculadora.\00"
@.str.2 = [10 x i8] c"\0ALetra A:\00"
@.str.3 = [38 x i8] c"\09Valores:\0A\09\09x=%.2f\0A\09\09i=%.2f\0A\09\09j=%.2f\0A\00"
@.str.4 = [25 x i8] c"\09Operacao A: x ^ (i + j)\00"
@.str.5 = [18 x i8] c"\09Resultado: %.2f\0A\00"
@.str.6 = [10 x i8] c"\0ALetra B:\00"
@.str.7 = [38 x i8] c"\09Valores:\0A\09\09a=%.2f\0A\09\09b=%.2f\0A\09\09c=%.2f\0A\00"
@.str.8 = [51 x i8] c"\09Operacao B: (a + b) * [ 2 - ( c^2 / [1 - c^3] ) ]\00"
@.str.9 = [18 x i8] c"\09Resultado: %.6f\0A\00"
@.str.10 = [10 x i8] c"\0ALetra C:\00"
@.str.11 = [20 x i8] c"\09Valores:\0A\09\09y=%.2f\0A\00"
@.str.12 = [31 x i8] c"\09Operacao C: 2 / (2 - (5 * y))\00"
@.str.13 = [10 x i8] c"\0ALetra D:\00"
@.str.14 = [47 x i8] c"\09Valores:\0A\09\09A=%.2f\0A\09\09B=%.2f\0A\09\09C=%.2f\0A\09\09D=%.2f\0A\00"
@.str.15 = [31 x i8] c"\09Operacao D: A + (B / (C + D))\00"
@.str.16 = [10 x i8] c"\0ALetra E:\00"
@.str.17 = [38 x i8] c"\09Valores:\0A\09\09r=%.2f\0A\09\09s=%.2f\0A\09\09t=%.2f\0A\00"
@.str.18 = [41 x i8] c"\09Operacao E: 1 / ((1/r) + (1/s) + (1/t))\00"
@.str.19 = [10 x i8] c"\0ALetra F:\00"
@.str.20 = [29 x i8] c"\09Valores:\0A\09\09m=%.2f\0A\09\09n=%.2f\0A\00"
@.str.21 = [26 x i8] c"\09Operacao A: 20 / (m + n)\00"
@.str.22 = [18 x i8] c"\09Resultado: %.4f\0A\00"
@.str.23 = [29 x i8] c"\0ALetra G: Repetida (letra B)\00"
@.str.24 = [10 x i8] c"\0ALetra H:\00"
@.str.25 = [47 x i8] c"\09Valores:\0A\09\09p=%.2f\0A\09\09w=%.2f\0A\09\09u=%.2f\0A\09\09v=%.2f\0A\00"
@.str.26 = [55 x i8] c"\09Operacao H: (p + (w / (u + v))) / (p - (w / (u - v)))\00"
@.str.27 = [10 x i8] c"\0ALetra I:\00"
@.str.28 = [51 x i8] c"\09Valores:\0A\09\09_a=%.2f\0A\09\09_b=%.2f\0A\09\09_c=%.2f\0A\09\09_d=%.2f\0A\00"
@.str.29 = [35 x i8] c"\09Operacao I: _a / (_b + (_c / _d))\00"
@.str.30 = [10 x i8] c"\0ALetra J:\00"
@.str.31 = [20 x i8] c"\09Valores:\0A\09\09N=%.2f\0A\00"
@.str.32 = [31 x i8] c"\09Operacao J: (1 + (1 / N)) ^ N\00"
@.str.33 = [10 x i8] c"\0ALetra K:\00"
@.str.34 = [29 x i8] c"\09Valores:\0A\09\09X=%.2f\0A\09\09Y=%.2f\0A\00"
@.str.35 = [37 x i8] c"\09Operacao K: 0.5 * (sqrt(X^2 + Y^2))\00"
@.str.36 = [10 x i8] c"\0ALetra L:\00"
@.str.37 = [41 x i8] c"\09Valores:\0A\09\09_A=%.2f\0A\09\09_B=%.2f\0A\09\09_C=%.2f\0A\00"
@.str.38 = [47 x i8] c"\09Operacao L: sqrt(_A + _B) / (_C^2 - (2 * _A))\00"
@.str.39 = [10 x i8] c"\0ALetra M:\00"
@.str.40 = [40 x i8] c"\09Valores:\0A\09\09_x=%.2f\0A\09\09_y=%.2f\0A\09\09g=%.2f\0A\00"
@.str.41 = [33 x i8] c"\09Operacao M: (_x / _y) ^ (g - 1)\00"
define void @ex3() {
%1 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%2 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([293 x i8], [293 x i8]* @.str.1, i64 0, i64 0))
%3 = tail call i32 (...) @rand()
%4 = srem i32 %3, 5
%5 = add nsw i32 %4, 1
%6 = sitofp i32 %5 to float
%7 = tail call i32 (...) @rand()
%8 = srem i32 %7, 5
%9 = add nsw i32 %8, 1
%10 = sitofp i32 %9 to float
%11 = tail call i32 (...) @rand()
%12 = srem i32 %11, 5
%13 = add nsw i32 %12, 1
%14 = sitofp i32 %13 to float
%15 = fpext float %6 to double
%16 = fadd float %10, %14
%17 = fpext float %16 to double
%18 = tail call double @pow(double %15, double %17)
%19 = fptrunc double %18 to float
%20 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%21 = fpext float %10 to double
%22 = fpext float %14 to double
%23 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.3, i64 0, i64 0), double %15, double %21, double %22)
%24 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.4, i64 0, i64 0))
%25 = fpext float %19 to double
%26 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), double %25)
%27 = tail call i32 (...) @rand()
%28 = srem i32 %27, 5
%29 = add nsw i32 %28, 1
%30 = sitofp i32 %29 to float
%31 = tail call i32 (...) @rand()
%32 = srem i32 %31, 5
%33 = add nsw i32 %32, 1
%34 = sitofp i32 %33 to float
%35 = tail call i32 (...) @rand()
%36 = srem i32 %35, 5
%37 = add nsw i32 %36, 1
%38 = sitofp i32 %37 to float
%39 = fadd float %30, %34
%40 = fpext float %39 to double
%41 = fpext float %38 to double
%42 = fmul double %41, %41
%43 = tail call double @pow(double %41, double 3.000000e+00)
%44 = fsub double 1.000000e+00, %43
%45 = fdiv double %42, %44
%46 = fsub double 2.000000e+00, %45
%47 = fmul double %46, %40
%48 = fptrunc double %47 to float
%49 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%50 = fpext float %30 to double
%51 = fpext float %34 to double
%52 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.7, i64 0, i64 0), double %50, double %51, double %41)
%53 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.8, i64 0, i64 0))
%54 = fpext float %48 to double
%55 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %54)
%56 = tail call i32 (...) @rand()
%57 = srem i32 %56, 5
%58 = add nsw i32 %57, 1
%59 = sitofp i32 %58 to float
%60 = tail call float @llvm.fmuladd.f32(float %59, float -5.000000e+00, float 2.000000e+00)
%61 = fdiv float 2.000000e+00, %60
%62 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
%63 = fpext float %59 to double
%64 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.11, i64 0, i64 0), double %63)
%65 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.12, i64 0, i64 0))
%66 = fpext float %61 to double
%67 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %66)
%68 = tail call i32 (...) @rand()
%69 = srem i32 %68, 5
%70 = add nsw i32 %69, 1
%71 = sitofp i32 %70 to float
%72 = tail call i32 (...) @rand()
%73 = srem i32 %72, 5
%74 = add nsw i32 %73, 1
%75 = sitofp i32 %74 to float
%76 = tail call i32 (...) @rand()
%77 = srem i32 %76, 5
%78 = add nsw i32 %77, 1
%79 = sitofp i32 %78 to float
%80 = tail call i32 (...) @rand()
%81 = srem i32 %80, 5
%82 = add nsw i32 %81, 1
%83 = sitofp i32 %82 to float
%84 = fadd float %79, %83
%85 = fdiv float %75, %84
%86 = fadd float %85, %71
%87 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%88 = fpext float %71 to double
%89 = fpext float %75 to double
%90 = fpext float %79 to double
%91 = fpext float %83 to double
%92 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.14, i64 0, i64 0), double %88, double %89, double %90, double %91)
%93 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.15, i64 0, i64 0))
%94 = fpext float %86 to double
%95 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %94)
%96 = tail call i32 (...) @rand()
%97 = tail call i32 (...) @rand()
%98 = srem i32 %97, 5
%99 = add nsw i32 %98, 1
%100 = sitofp i32 %99 to float
%101 = tail call i32 (...) @rand()
%102 = insertelement <2 x i32> poison, i32 %96, i64 0
%103 = insertelement <2 x i32> %102, i32 %101, i64 1
%104 = srem <2 x i32> %103, <i32 5, i32 5>
%105 = add nsw <2 x i32> %104, <i32 1, i32 1>
%106 = sitofp <2 x i32> %105 to <2 x float>
%107 = fdiv float 1.000000e+00, %100
%108 = fdiv <2 x float> <float 1.000000e+00, float 1.000000e+00>, %106
%109 = extractelement <2 x float> %108, i64 0
%110 = fadd float %109, %107
%111 = extractelement <2 x float> %108, i64 1
%112 = fadd float %110, %111
%113 = fdiv float 1.000000e+00, %112
%114 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.16, i64 0, i64 0))
%115 = extractelement <2 x float> %106, i64 0
%116 = fpext float %115 to double
%117 = fpext float %100 to double
%118 = extractelement <2 x float> %106, i64 1
%119 = fpext float %118 to double
%120 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.17, i64 0, i64 0), double %116, double %117, double %119)
%121 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.18, i64 0, i64 0))
%122 = fpext float %113 to double
%123 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %122)
%124 = tail call i32 (...) @rand()
%125 = srem i32 %124, 5
%126 = add nsw i32 %125, 1
%127 = sitofp i32 %126 to float
%128 = tail call i32 (...) @rand()
%129 = srem i32 %128, 5
%130 = add nsw i32 %129, 1
%131 = sitofp i32 %130 to float
%132 = fadd float %127, %131
%133 = fdiv float 2.000000e+01, %132
%134 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.19, i64 0, i64 0))
%135 = fpext float %127 to double
%136 = fpext float %131 to double
%137 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.20, i64 0, i64 0), double %135, double %136)
%138 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.21, i64 0, i64 0))
%139 = fpext float %133 to double
%140 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.22, i64 0, i64 0), double %139)
%141 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.23, i64 0, i64 0))
%142 = tail call i32 (...) @rand()
%143 = srem i32 %142, 5
%144 = add nsw i32 %143, 1
%145 = sitofp i32 %144 to float
%146 = tail call i32 (...) @rand()
%147 = srem i32 %146, 5
%148 = add nsw i32 %147, 1
%149 = sitofp i32 %148 to float
%150 = tail call i32 (...) @rand()
%151 = srem i32 %150, 5
%152 = add nsw i32 %151, 1
%153 = sitofp i32 %152 to float
%154 = tail call i32 (...) @rand()
%155 = srem i32 %154, 5
%156 = add nsw i32 %155, 1
%157 = sitofp i32 %156 to float
%158 = fcmp oeq float %157, %153
br i1 %158, label %159, label %165
159: ; preds = %0, %159
%160 = tail call i32 (...) @rand()
%161 = srem i32 %160, 5
%162 = add nsw i32 %161, 1
%163 = sitofp i32 %162 to float
%164 = fcmp oeq float %163, %153
br i1 %164, label %159, label %165
165: ; preds = %159, %0
%166 = phi float [ %157, %0 ], [ %163, %159 ]
%167 = fadd float %166, %153
%168 = fdiv float %149, %167
%169 = fadd float %168, %145
%170 = fsub float %153, %166
%171 = fdiv float %149, %170
%172 = fsub float %145, %171
%173 = fdiv float %169, %172
%174 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.24, i64 0, i64 0))
%175 = fpext float %145 to double
%176 = fpext float %149 to double
%177 = fpext float %153 to double
%178 = fpext float %166 to double
%179 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.25, i64 0, i64 0), double %175, double %176, double %177, double %178)
%180 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.26, i64 0, i64 0))
%181 = fpext float %173 to double
%182 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.22, i64 0, i64 0), double %181)
%183 = tail call i32 (...) @rand()
%184 = srem i32 %183, 5
%185 = add nsw i32 %184, 1
%186 = sitofp i32 %185 to float
%187 = tail call i32 (...) @rand()
%188 = srem i32 %187, 5
%189 = add nsw i32 %188, 1
%190 = sitofp i32 %189 to float
%191 = tail call i32 (...) @rand()
%192 = srem i32 %191, 5
%193 = add nsw i32 %192, 1
%194 = sitofp i32 %193 to float
%195 = tail call i32 (...) @rand()
%196 = srem i32 %195, 5
%197 = add nsw i32 %196, 1
%198 = sitofp i32 %197 to float
%199 = fdiv float %194, %198
%200 = fadd float %199, %190
%201 = fdiv float %186, %200
%202 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.27, i64 0, i64 0))
%203 = fpext float %186 to double
%204 = fpext float %190 to double
%205 = fpext float %194 to double
%206 = fpext float %198 to double
%207 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.28, i64 0, i64 0), double %203, double %204, double %205, double %206)
%208 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.29, i64 0, i64 0))
%209 = fpext float %201 to double
%210 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %209)
%211 = tail call i32 (...) @rand()
%212 = srem i32 %211, 5
%213 = add nsw i32 %212, 1
%214 = sitofp i32 %213 to float
%215 = fdiv float 1.000000e+00, %214
%216 = fadd float %215, 1.000000e+00
%217 = fpext float %216 to double
%218 = fpext float %214 to double
%219 = tail call double @pow(double %217, double %218)
%220 = fptrunc double %219 to float
%221 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.30, i64 0, i64 0))
%222 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.31, i64 0, i64 0), double %218)
%223 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.32, i64 0, i64 0))
%224 = fpext float %220 to double
%225 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %224)
%226 = tail call i32 (...) @rand()
%227 = srem i32 %226, 5
%228 = add nsw i32 %227, 1
%229 = sitofp i32 %228 to float
%230 = tail call i32 (...) @rand()
%231 = srem i32 %230, 5
%232 = add nsw i32 %231, 1
%233 = sitofp i32 %232 to float
%234 = fpext float %229 to double
%235 = fmul double %234, %234
%236 = fpext float %233 to double
%237 = fmul double %236, %236
%238 = fadd double %235, %237
%239 = tail call double @sqrt(double %238)
%240 = fmul double %239, 5.000000e-01
%241 = fptrunc double %240 to float
%242 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.33, i64 0, i64 0))
%243 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.34, i64 0, i64 0), double %234, double %236)
%244 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.35, i64 0, i64 0))
%245 = fpext float %241 to double
%246 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %245)
%247 = tail call i32 (...) @rand()
%248 = srem i32 %247, 5
%249 = add nsw i32 %248, 1
%250 = sitofp i32 %249 to float
%251 = tail call i32 (...) @rand()
%252 = srem i32 %251, 5
%253 = add nsw i32 %252, 1
%254 = sitofp i32 %253 to float
%255 = tail call i32 (...) @rand()
%256 = srem i32 %255, 5
%257 = add nsw i32 %256, 1
%258 = sitofp i32 %257 to float
%259 = fadd float %250, %254
%260 = fpext float %259 to double
%261 = tail call double @sqrt(double %260)
%262 = fpext float %258 to double
%263 = fmul double %262, %262
%264 = fmul float %250, 2.000000e+00
%265 = fpext float %264 to double
%266 = fsub double %263, %265
%267 = fdiv double %261, %266
%268 = fptrunc double %267 to float
%269 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.36, i64 0, i64 0))
%270 = fpext float %250 to double
%271 = fpext float %254 to double
%272 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.37, i64 0, i64 0), double %270, double %271, double %262)
%273 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.38, i64 0, i64 0))
%274 = fpext float %268 to double
%275 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %274)
%276 = tail call i32 (...) @rand()
%277 = srem i32 %276, 5
%278 = add nsw i32 %277, 1
%279 = sitofp i32 %278 to float
%280 = tail call i32 (...) @rand()
%281 = srem i32 %280, 5
%282 = add nsw i32 %281, 1
%283 = sitofp i32 %282 to float
%284 = tail call i32 (...) @rand()
%285 = srem i32 %284, 5
%286 = add nsw i32 %285, 1
%287 = sitofp i32 %286 to float
%288 = fdiv float %279, %283
%289 = fpext float %288 to double
%290 = fadd float %287, -1.000000e+00
%291 = fpext float %290 to double
%292 = tail call double @pow(double %289, double %291)
%293 = fptrunc double %292 to float
%294 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.39, i64 0, i64 0))
%295 = fpext float %279 to double
%296 = fpext float %283 to double
%297 = fpext float %287 to double
%298 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.40, i64 0, i64 0), double %295, double %296, double %297)
%299 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.41, i64 0, i64 0))
%300 = fpext float %293 to double
%301 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0), double %300)
%302 = tail call i32 (i8*, ...) bitcast (i32 (...)* @print to i32 (i8*, ...)*)(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
ret void
}