#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 *, float *, float *);
float stub1(float);
void scrsho(float (*fx)(float)) {
  int jz, j, i;
  float ysml, ybig, x2, x1, x, dyj, dx, y[60 + 1];
  char scr[60 + 1][21 + 1];
  for (;;) {
    printf("\nEnter x1 x2 (x1=x2 to stop):\n");
    scanf("%f %f", &x1, &x2);
    if (x1 == x2)
      break;
    for (j = 1; j <= 21; j++)
      scr[1][j] = scr[60][j] = 'l';
    for (i = 2; i <= (60 - 1); i++) {
      scr[i][1] = scr[i][21] = '-';
      for (j = 2; j <= (21 - 1); j++)
        scr[i][j] = ' ';
    }
    dx = (x2 - x1) / (60 - 1);
    x = x1;
    ysml = ybig = 0.0;
    for (i = 1; i <= 60; i++) {
      y[i] = (*fx)(x);
      if (y[i] < ysml)
        ysml = y[i];
      if (y[i] > ybig)
        ybig = y[i];
      x += dx;
    }
    if (ybig == ysml)
      ybig = ysml + 1.0;
    dyj = (21 - 1) / (ybig - ysml);
    jz = 1 - (int)(ysml * dyj);
    for (i = 1; i <= 60; i++) {
      scr[i][jz] = '-';
      j = 1 + (int)((y[i] - ysml) * dyj);
      scr[i][j] = 'x';
    }
    printf(" %10.3f ", ybig);
    for (i = 1; i <= 60; i++)
      printf("%c", scr[i][21]);
    printf("\n");
    for (j = (21 - 1); j >= 2; j--) {
      printf("%12s", " ");
      for (i = 1; i <= 60; i++)
        printf("%c", scr[i][j]);
      printf("\n");
    }
    printf(" %10.3f ", ysml);
    for (i = 1; i <= 60; i++)
      printf("%c", scr[i][1]);
    printf("\n");
    printf("%8s %10.3f %44s %10.3f\n", " ", x1, " ", x2);
  }
}


x86 assembly (clang, -O0):
<scrsho>:
push   %rbp
mov    %rsp,%rbp
sub    $0x670,%rsp
mov    %rdi,-0x8(%rbp)
lea    0xeda(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeeb(%rip),%rdi
lea    -0x24(%rbp),%rsi
lea    -0x20(%rbp),%rdx
call   1040 <scanf@plt>
movss  -0x24(%rbp),%xmm0
ucomiss -0x20(%rbp),%xmm0
jne    116b <scrsho+0x4b>
jp     116b <scrsho+0x4b>
jmp    155e <scrsho+0x43e>
movl   $0x1,-0x10(%rbp)
cmpl   $0x15,-0x10(%rbp)
jg     11a2 <scrsho+0x82>
movslq -0x10(%rbp),%rax
movb   $0x6c,-0x148(%rbp,%rax,1)
6c
movslq -0x10(%rbp),%rax
movb   $0x6c,-0x65a(%rbp,%rax,1)
6c
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1172 <scrsho+0x52>
movl   $0x2,-0x14(%rbp)
cmpl   $0x3b,-0x14(%rbp)
jg     122b <scrsho+0x10b>
movslq -0x14(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0x16,%rcx,%rcx
add    %rcx,%rax
movb   $0x2d,0x15(%rax)
movslq -0x14(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0x16,%rcx,%rcx
add    %rcx,%rax
movb   $0x2d,0x1(%rax)
movl   $0x2,-0x10(%rbp)
cmpl   $0x14,-0x10(%rbp)
jg     1218 <scrsho+0xf8>
movslq -0x14(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0x16,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11e6 <scrsho+0xc6>
jmp    121d <scrsho+0xfd>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a9 <scrsho+0x89>
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  0xdc3(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
movl   $0x1,-0x14(%rbp)
cmpl   $0x3c,-0x14(%rbp)
jg     12fc <scrsho+0x1dc>
mov    -0x8(%rbp),%rax
movss  -0x28(%rbp),%xmm0
call   *%rax
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x130(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x130(%rbp,%rax,4),%xmm1
ff ff
movss  -0x18(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    12b6 <scrsho+0x196>
movslq -0x14(%rbp),%rax
movss  -0x130(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x18(%rbp)
movslq -0x14(%rbp),%rax
movss  -0x130(%rbp,%rax,4),%xmm0
ff ff
ucomiss -0x1c(%rbp),%xmm0
jbe    12df <scrsho+0x1bf>
movslq -0x14(%rbp),%rax
movss  -0x130(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1c(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1267 <scrsho+0x147>
movss  -0x1c(%rbp),%xmm0
ucomiss -0x18(%rbp),%xmm0
jne    132f <scrsho+0x20f>
jp     132f <scrsho+0x20f>
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xce6(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm1
subss  -0x18(%rbp),%xmm1
movss  0xcc3(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
cvttss2si %xmm0,%ecx
mov    $0x1,%eax
sub    %ecx,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1,-0x14(%rbp)
cmpl   $0x3c,-0x14(%rbp)
jg     13d6 <scrsho+0x2b6>
movslq -0x14(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0x16,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movb   $0x2d,(%rax,%rcx,1)
movslq -0x14(%rbp),%rax
movss  -0x130(%rbp,%rax,4),%xmm0
ff ff
subss  -0x18(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
cvttss2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
movslq -0x14(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0x16,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movb   $0x78,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1369 <scrsho+0x249>
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc4f(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movl   $0x1,-0x14(%rbp)
cmpl   $0x3c,-0x14(%rbp)
jg     1430 <scrsho+0x310>
movslq -0x14(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0x16,%rcx,%rcx
add    %rcx,%rax
movsbl 0x15(%rax),%esi
lea    0xc23(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13f4 <scrsho+0x2d4>
lea    0xbf6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x14,-0x10(%rbp)
cmpl   $0x2,-0x10(%rbp)
jl     14c7 <scrsho+0x3a7>
lea    0xbeb(%rip),%rdi
lea    0xbdf(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x14(%rbp)
cmpl   $0x3c,-0x14(%rbp)
jg     14ab <scrsho+0x38b>
movslq -0x14(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0x16,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xba8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    146b <scrsho+0x34b>
lea    0xb7b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1445 <scrsho+0x325>
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb5e(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movl   $0x1,-0x14(%rbp)
cmpl   $0x3c,-0x14(%rbp)
jg     1521 <scrsho+0x401>
movslq -0x14(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0x16,%rcx,%rcx
add    %rcx,%rax
movsbl 0x1(%rax),%esi
lea    0xb32(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14e5 <scrsho+0x3c5>
lea    0xb05(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xafe(%rip),%rdi
lea    0xaed(%rip),%rdx
mov    %rdx,%rsi
mov    $0x2,%al
call   1030 <printf@plt>
jmp    112f <scrsho+0xf>
add    $0x670,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scrsho>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x678,%rsp
mov    %rdi,%r15
lea    0xefd(%rip),%rdi
call   1040 <puts@plt>
lea    0xec5(%rip),%rdi
lea    0xc(%rsp),%rsi
lea    0x10(%rsp),%rdx
call   1060 <scanf@plt>
movss  0xc(%rsp),%xmm2
movss  0x10(%rsp),%xmm4
ucomiss %xmm4,%xmm2
jne    118d <scrsho+0x4d>
jnp    14b0 <scrsho+0x370>
lea    0x147(%rsp),%rbp
movaps 0xe74(%rip),%xmm1
lea    0xe8f(%rip),%r14
lea    0xe8f(%rip),%r12
nopw   0x0(%rax,%rax,1)
movabs $0x6c6c6c6c6c6c6c6c,%rax
6c 6c 6c
mov    %rax,0xd(%rbp)
movaps 0xe3b(%rip),%xmm0
movups %xmm0,0x0(%rbp)
mov    %rax,0x51f(%rbp)
movups %xmm0,0x512(%rbp)
xor    %eax,%eax
nopl   0x0(%rax)
movb   $0x2d,0x171(%rsp,%rax,1)
2d
movb   $0x2d,0x15d(%rsp,%rax,1)
2d
movups %xmm1,0x17(%rbp,%rax,1)
movl   $0x20202020,0x26(%rbp,%rax,1)
20
movb   $0x2d,0x187(%rsp,%rax,1)
2d
movb   $0x2d,0x173(%rsp,%rax,1)
2d
movups %xmm1,0x2d(%rbp,%rax,1)
movl   $0x20202020,0x3c(%rbp,%rax,1)
20
add    $0x2c,%rax
cmp    $0x4fc,%rax
jne    11e0 <scrsho+0xa0>
subss  %xmm2,%xmm4
divss  0xdee(%rip),%xmm4
xorps  %xmm0,%xmm0
mov    $0x1,%ebx
xorps  %xmm3,%xmm3
movss  %xmm4,0x14(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm2,0x20(%rsp)
movss  %xmm3,0x18(%rsp)
movss  %xmm0,0x1c(%rsp)
movaps %xmm2,%xmm0
call   *%r15
movss  0x14(%rsp),%xmm4
movss  0x20(%rsp),%xmm2
movss  %xmm0,0x30(%rsp,%rbx,4)
movaps %xmm0,%xmm3
minss  0x18(%rsp),%xmm3
maxss  0x1c(%rsp),%xmm0
addss  %xmm4,%xmm2
add    $0x1,%rbx
cmp    $0x3d,%rbx
jne    1250 <scrsho+0x110>
movaps %xmm3,%xmm2
addss  0xd82(%rip),%xmm2
movaps %xmm0,%xmm1
cmpeqss %xmm3,%xmm1
andps  %xmm1,%xmm2
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
movaps %xmm1,%xmm2
subss  %xmm3,%xmm2
movss  0xd66(%rip),%xmm0
divss  %xmm2,%xmm0
movaps %xmm3,%xmm2
mulss  %xmm0,%xmm2
cvttss2si %xmm2,%eax
mov    $0x1,%ecx
sub    %eax,%ecx
movslq %ecx,%rax
add    $0xffffffffffffffff,%rax
mov    $0x2,%ecx
mov    %rbp,%rdx
nopw   0x0(%rax,%rax,1)
movb   $0x2d,(%rdx,%rax,1)
movss  0x2c(%rsp,%rcx,4),%xmm2
subss  %xmm3,%xmm2
mulss  %xmm0,%xmm2
cvttss2si %xmm2,%esi
movslq %esi,%rsi
movb   $0x78,(%rsi,%rdx,1)
movb   $0x2d,0x16(%rdx,%rax,1)
movss  0x30(%rsp,%rcx,4),%xmm2
subss  %xmm3,%xmm2
mulss  %xmm0,%xmm2
cvttss2si %xmm2,%esi
movslq %esi,%rsi
movb   $0x78,0x16(%rsi,%rdx,1)
add    $0x2,%rcx
add    $0x2c,%rdx
cmp    $0x3e,%rcx
jne    12f0 <scrsho+0x1b0>
movaps %xmm3,0x20(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0x2b,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsbl 0x130(%rsp,%rbx,1),%edi
call   1030 <putchar@plt>
add    $0x16,%rbx
cmp    $0x553,%rbx
jne    1360 <scrsho+0x220>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    $0x14,%r14d
lea    0x130(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0xc94(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x2a,%ebx
cs nopw 0x0(%rax,%rax,1)
movsbl 0x0(%r13,%rbx,1),%edi
call   1030 <putchar@plt>
add    $0x16,%rbx
cmp    $0x552,%rbx
jne    13c0 <scrsho+0x280>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    -0x1(%r14),%rax
add    $0xffffffffffffffff,%r13
cmp    $0x2,%r14
mov    %rax,%r14
ja     13a0 <scrsho+0x260>
movaps 0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc2f(%rip),%r14
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0x17,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsbl 0x130(%rsp,%rbx,1),%edi
call   1030 <putchar@plt>
add    $0x16,%rbx
cmp    $0x53f,%rbx
jne    1420 <scrsho+0x2e0>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xbe1(%rip),%rdi
mov    %r12,%rsi
mov    %r12,%rdx
mov    $0x2,%al
call   1050 <printf@plt>
lea    0xbe5(%rip),%rdi
call   1040 <puts@plt>
lea    0xbad(%rip),%rdi
lea    0xc(%rsp),%rsi
lea    0x10(%rsp),%rdx
call   1060 <scanf@plt>
movss  0xc(%rsp),%xmm2
movss  0x10(%rsp),%xmm4
ucomiss %xmm4,%xmm2
movaps 0xb6c(%rip),%xmm1
jne    11b0 <scrsho+0x70>
jp     11b0 <scrsho+0x70>
add    $0x678,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [31 x i8] c"\0AEnter x1 x2 (x1=x2 to stop):\0A\00"
@.str.1 = [6 x i8] c"%f %f\00"
@.str.2 = [9 x i8] c" %10.3f \00"
@.str.3 = [3 x i8] c"%c\00"
@.str.4 = [2 x i8] c"\0A\00"
@.str.5 = [5 x i8] c"%12s\00"
@.str.6 = [2 x i8] c" \00"
@.str.7 = [24 x i8] c"%8s %10.3f %44s %10.3f\0A\00"
define void @scrsho(float (float)* %0) {
%2 = alloca float (float)*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca [61 x float]
%14 = alloca [61 x [22 x i8]]
store float (float)* %0, float (float)** %2
br label %15
15: ; preds = %226, %1
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
%17 = call i32 @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), float* %9, float* %8)
%18 = load float, float* %9
%19 = load float, float* %8
%20 = fcmp oeq float %18, %19
br i1 %20, label %21, label %22
21: ; preds = %15
br label %233
22: ; preds = %15
store i32 1, i32* %4
br label %23
23: ; preds = %35, %22
%24 = load i32, i32* %4
%25 = icmp sle i32 %24, 21
br i1 %25, label %26, label %38
26: ; preds = %23
%27 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 60
%28 = load i32, i32* %4
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [22 x i8], [22 x i8]* %27, i64 0, i64 %29
store i8 108, i8* %30
%31 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 1
%32 = load i32, i32* %4
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [22 x i8], [22 x i8]* %31, i64 0, i64 %33
store i8 108, i8* %34
br label %35
35: ; preds = %26
%36 = load i32, i32* %4
%37 = add nsw i32 %36, 1
store i32 %37, i32* %4
br label %23
38: ; preds = %23
store i32 2, i32* %5
br label %39
39: ; preds = %65, %38
%40 = load i32, i32* %5
%41 = icmp sle i32 %40, 59
br i1 %41, label %42, label %68
42: ; preds = %39
%43 = load i32, i32* %5
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 %44
%46 = getelementptr inbounds [22 x i8], [22 x i8]* %45, i64 0, i64 21
store i8 45, i8* %46
%47 = load i32, i32* %5
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 %48
%50 = getelementptr inbounds [22 x i8], [22 x i8]* %49, i64 0, i64 1
store i8 45, i8* %50
store i32 2, i32* %4
br label %51
51: ; preds = %61, %42
%52 = load i32, i32* %4
%53 = icmp sle i32 %52, 20
br i1 %53, label %54, label %64
54: ; preds = %51
%55 = load i32, i32* %5
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 %56
%58 = load i32, i32* %4
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [22 x i8], [22 x i8]* %57, i64 0, i64 %59
store i8 32, i8* %60
br label %61
61: ; preds = %54
%62 = load i32, i32* %4
%63 = add nsw i32 %62, 1
store i32 %63, i32* %4
br label %51
64: ; preds = %51
br label %65
65: ; preds = %64
%66 = load i32, i32* %5
%67 = add nsw i32 %66, 1
store i32 %67, i32* %5
br label %39
68: ; preds = %39
%69 = load float, float* %8
%70 = load float, float* %9
%71 = fsub float %69, %70
%72 = fdiv float %71, 5.900000e+01
store float %72, float* %12
%73 = load float, float* %9
store float %73, float* %10
store float 0.000000e+00, float* %7
store float 0.000000e+00, float* %6
store i32 1, i32* %5
br label %74
74: ; preds = %111, %68
%75 = load i32, i32* %5
%76 = icmp sle i32 %75, 60
br i1 %76, label %77, label %114
77: ; preds = %74
%78 = load float (float)*, float (float)** %2
%79 = load float, float* %10
%80 = call float %78(float %79)
%81 = load i32, i32* %5
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [61 x float], [61 x float]* %13, i64 0, i64 %82
store float %80, float* %83
%84 = load i32, i32* %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [61 x float], [61 x float]* %13, i64 0, i64 %85
%87 = load float, float* %86
%88 = load float, float* %6
%89 = fcmp olt float %87, %88
br i1 %89, label %90, label %95
90: ; preds = %77
%91 = load i32, i32* %5
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [61 x float], [61 x float]* %13, i64 0, i64 %92
%94 = load float, float* %93
store float %94, float* %6
br label %95
95: ; preds = %90, %77
%96 = load i32, i32* %5
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [61 x float], [61 x float]* %13, i64 0, i64 %97
%99 = load float, float* %98
%100 = load float, float* %7
%101 = fcmp ogt float %99, %100
br i1 %101, label %102, label %107
102: ; preds = %95
%103 = load i32, i32* %5
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [61 x float], [61 x float]* %13, i64 0, i64 %104
%106 = load float, float* %105
store float %106, float* %7
br label %107
107: ; preds = %102, %95
%108 = load float, float* %12
%109 = load float, float* %10
%110 = fadd float %109, %108
store float %110, float* %10
br label %111
111: ; preds = %107
%112 = load i32, i32* %5
%113 = add nsw i32 %112, 1
store i32 %113, i32* %5
br label %74
114: ; preds = %74
%115 = load float, float* %7
%116 = load float, float* %6
%117 = fcmp oeq float %115, %116
br i1 %117, label %118, label %123
118: ; preds = %114
%119 = load float, float* %6
%120 = fpext float %119 to double
%121 = fadd double %120, 1.000000e+00
%122 = fptrunc double %121 to float
store float %122, float* %7
br label %123
123: ; preds = %118, %114
%124 = load float, float* %7
%125 = load float, float* %6
%126 = fsub float %124, %125
%127 = fdiv float 2.000000e+01, %126
store float %127, float* %11
%128 = load float, float* %6
%129 = load float, float* %11
%130 = fmul float %128, %129
%131 = fptosi float %130 to i32
%132 = sub nsw i32 1, %131
store i32 %132, i32* %3
store i32 1, i32* %5
br label %133
133: ; preds = %159, %123
%134 = load i32, i32* %5
%135 = icmp sle i32 %134, 60
br i1 %135, label %136, label %162
136: ; preds = %133
%137 = load i32, i32* %5
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 %138
%140 = load i32, i32* %3
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [22 x i8], [22 x i8]* %139, i64 0, i64 %141
store i8 45, i8* %142
%143 = load i32, i32* %5
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [61 x float], [61 x float]* %13, i64 0, i64 %144
%146 = load float, float* %145
%147 = load float, float* %6
%148 = fsub float %146, %147
%149 = load float, float* %11
%150 = fmul float %148, %149
%151 = fptosi float %150 to i32
%152 = add nsw i32 1, %151
store i32 %152, i32* %4
%153 = load i32, i32* %5
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 %154
%156 = load i32, i32* %4
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [22 x i8], [22 x i8]* %155, i64 0, i64 %157
store i8 120, i8* %158
br label %159
159: ; preds = %136
%160 = load i32, i32* %5
%161 = add nsw i32 %160, 1
store i32 %161, i32* %5
br label %133
162: ; preds = %133
%163 = load float, float* %7
%164 = fpext float %163 to double
%165 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %164)
store i32 1, i32* %5
br label %166
166: ; preds = %177, %162
%167 = load i32, i32* %5
%168 = icmp sle i32 %167, 60
br i1 %168, label %169, label %180
169: ; preds = %166
%170 = load i32, i32* %5
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 %171
%173 = getelementptr inbounds [22 x i8], [22 x i8]* %172, i64 0, i64 21
%174 = load i8, i8* %173
%175 = sext i8 %174 to i32
%176 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32 %175)
br label %177
177: ; preds = %169
%178 = load i32, i32* %5
%179 = add nsw i32 %178, 1
store i32 %179, i32* %5
br label %166
180: ; preds = %166
%181 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
store i32 20, i32* %4
br label %182
182: ; preds = %205, %180
%183 = load i32, i32* %4
%184 = icmp sge i32 %183, 2
br i1 %184, label %185, label %208
185: ; preds = %182
%186 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
store i32 1, i32* %5
br label %187
187: ; preds = %200, %185
%188 = load i32, i32* %5
%189 = icmp sle i32 %188, 60
br i1 %189, label %190, label %203
190: ; preds = %187
%191 = load i32, i32* %5
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 %192
%194 = load i32, i32* %4
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [22 x i8], [22 x i8]* %193, i64 0, i64 %195
%197 = load i8, i8* %196
%198 = sext i8 %197 to i32
%199 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32 %198)
br label %200
200: ; preds = %190
%201 = load i32, i32* %5
%202 = add nsw i32 %201, 1
store i32 %202, i32* %5
br label %187
203: ; preds = %187
%204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %205
205: ; preds = %203
%206 = load i32, i32* %4
%207 = add nsw i32 %206, -1
store i32 %207, i32* %4
br label %182
208: ; preds = %182
%209 = load float, float* %6
%210 = fpext float %209 to double
%211 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %210)
store i32 1, i32* %5
br label %212
212: ; preds = %223, %208
%213 = load i32, i32* %5
%214 = icmp sle i32 %213, 60
br i1 %214, label %215, label %226
215: ; preds = %212
%216 = load i32, i32* %5
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %14, i64 0, i64 %217
%219 = getelementptr inbounds [22 x i8], [22 x i8]* %218, i64 0, i64 1
%220 = load i8, i8* %219
%221 = sext i8 %220 to i32
%222 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32 %221)
br label %223
223: ; preds = %215
%224 = load i32, i32* %5
%225 = add nsw i32 %224, 1
store i32 %225, i32* %5
br label %212
226: ; preds = %212
%227 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%228 = load float, float* %9
%229 = fpext float %228 to double
%230 = load float, float* %8
%231 = fpext float %230 to double
%232 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %229, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %231)
br label %15
233: ; preds = %21
ret void
}

LLVM IR (-O2):
@.str.1 = [6 x i8] c"%f %f\00"
@.str.2 = [9 x i8] c" %10.3f \00"
@.str.5 = [5 x i8] c"%12s\00"
@.str.6 = [2 x i8] c" \00"
@.str.7 = [24 x i8] c"%8s %10.3f %44s %10.3f\0A\00"
@str = [30 x i8] c"\0AEnter x1 x2 (x1=x2 to stop):\00"
define void @scrsho(float (float)* nocapture %0) {
%2 = alloca float
%3 = alloca float
%4 = alloca [61 x float]
%5 = alloca [61 x [22 x i8]]
%6 = bitcast float* %2 to i8*
%7 = bitcast float* %3 to i8*
%8 = bitcast [61 x float]* %4 to i8*
%9 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 0, i64 0
%10 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0))
%11 = call i32 @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), float* %3, float* %2)
%12 = load float, float* %3
%13 = load float, float* %2
%14 = fcmp oeq float %12, %13
br i1 %14, label %137, label %15
15: ; preds = %1
%16 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 1, i64 1
%17 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 60, i64 1
br label %18
18: ; preds = %15, %125
%19 = phi float [ %135, %125 ], [ %13, %15 ]
%20 = phi float [ %134, %125 ], [ %12, %15 ]
br label %21
21: ; preds = %21, %18
%22 = phi i64 [ 2, %18 ], [ %33, %21 ]
%23 = phi i64 [ 0, %18 ], [ %34, %21 ]
%24 = add nuw nsw i64 %23, 2
%25 = getelementptr [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %24, i64 2
%26 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %22, i64 21
store i8 45, i8* %26
%27 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %22, i64 1
store i8 45, i8* %27
%28 = or i64 %22, 1
%29 = add nuw nsw i64 %23, 3
%30 = getelementptr [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %29, i64 2
%31 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %28, i64 21
store i8 45, i8* %31
%32 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %28, i64 1
store i8 45, i8* %32
%33 = add nuw nsw i64 %22, 2
%34 = add nuw nsw i64 %23, 2
%35 = icmp eq i64 %34, 58
br i1 %35, label %36, label %21
36: ; preds = %21
%37 = fsub float %19, %20
%38 = fdiv float %37, 5.900000e+01
br label %39
39: ; preds = %36, %39
%40 = phi i64 [ 1, %36 ], [ %51, %39 ]
%41 = phi float [ %20, %36 ], [ %50, %39 ]
%42 = phi float [ 0.000000e+00, %36 ], [ %49, %39 ]
%43 = phi float [ 0.000000e+00, %36 ], [ %47, %39 ]
%44 = call float %0(float %41)
%45 = getelementptr inbounds [61 x float], [61 x float]* %4, i64 0, i64 %40
store float %44, float* %45
%46 = fcmp olt float %44, %43
%47 = select i1 %46, float %44, float %43
%48 = fcmp ogt float %44, %42
%49 = select i1 %48, float %44, float %42
%50 = fadd float %38, %41
%51 = add nuw nsw i64 %40, 1
%52 = icmp eq i64 %51, 61
br i1 %52, label %53, label %39
53: ; preds = %39
%54 = fcmp oeq float %49, %47
%55 = fadd float %47, 1.000000e+00
%56 = select i1 %54, float %55, float %49
%57 = fsub float %56, %47
%58 = fdiv float 2.000000e+01, %57
%59 = fmul float %47, %58
%60 = fptosi float %59 to i32
%61 = sub nsw i32 1, %60
%62 = sext i32 %61 to i64
br label %63
63: ; preds = %63, %53
%64 = phi i64 [ 1, %53 ], [ %84, %63 ]
%65 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %64, i64 %62
store i8 45, i8* %65
%66 = getelementptr inbounds [61 x float], [61 x float]* %4, i64 0, i64 %64
%67 = load float, float* %66
%68 = fsub float %67, %47
%69 = fmul float %58, %68
%70 = fptosi float %69 to i32
%71 = add nsw i32 %70, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %64, i64 %72
store i8 120, i8* %73
%74 = add nuw nsw i64 %64, 1
%75 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %74, i64 %62
store i8 45, i8* %75
%76 = getelementptr inbounds [61 x float], [61 x float]* %4, i64 0, i64 %74
%77 = load float, float* %76
%78 = fsub float %77, %47
%79 = fmul float %58, %78
%80 = fptosi float %79 to i32
%81 = add nsw i32 %80, 1
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %74, i64 %82
store i8 120, i8* %83
%84 = add nuw nsw i64 %64, 2
%85 = icmp eq i64 %84, 61
br i1 %85, label %86, label %63
86: ; preds = %63
%87 = fpext float %56 to double
%88 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %87)
br label %89
89: ; preds = %86, %89
%90 = phi i64 [ 1, %86 ], [ %95, %89 ]
%91 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %90, i64 21
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = call i32 @putchar(i32 %93)
%95 = add nuw nsw i64 %90, 1
%96 = icmp eq i64 %95, 61
br i1 %96, label %97, label %89
97: ; preds = %89
%98 = call i32 @putchar(i32 10)
br label %99
99: ; preds = %97, %110
%100 = phi i64 [ 20, %97 ], [ %112, %110 ]
%101 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %102
102: ; preds = %99, %102
%103 = phi i64 [ 1, %99 ], [ %108, %102 ]
%104 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %103, i64 %100
%105 = load i8, i8* %104
%106 = sext i8 %105 to i32
%107 = call i32 @putchar(i32 %106)
%108 = add nuw nsw i64 %103, 1
%109 = icmp eq i64 %108, 61
br i1 %109, label %110, label %102
110: ; preds = %102
%111 = call i32 @putchar(i32 10)
%112 = add nsw i64 %100, -1
%113 = icmp ugt i64 %100, 2
br i1 %113, label %99, label %114
114: ; preds = %110
%115 = fpext float %47 to double
%116 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %115)
br label %117
117: ; preds = %114, %117
%118 = phi i64 [ 1, %114 ], [ %123, %117 ]
%119 = getelementptr inbounds [61 x [22 x i8]], [61 x [22 x i8]]* %5, i64 0, i64 %118, i64 1
%120 = load i8, i8* %119
%121 = sext i8 %120 to i32
%122 = call i32 @putchar(i32 %121)
%123 = add nuw nsw i64 %118, 1
%124 = icmp eq i64 %123, 61
br i1 %124, label %125, label %117
125: ; preds = %117
%126 = call i32 @putchar(i32 10)
%127 = load float, float* %3
%128 = fpext float %127 to double
%129 = load float, float* %2
%130 = fpext float %129 to double
%131 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %128, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %130)
%132 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0))
%133 = call i32 @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), float* %3, float* %2)
%134 = load float, float* %3
%135 = load float, float* %2
%136 = fcmp oeq float %134, %135
br i1 %136, label %137, label %18
137: ; preds = %125, %1
ret void
}