main() {
  int i, n;
  float y[10], k1, k2, k3, k4, t, h, a, b, true, error;
  clrscr();
  printf("Please input limits and sections.\n");
  scanf("%f,%f,%d", &a, &b, &n);
  y[0] = 1;
  h = (b - a) / n;
  printf("-----------------------------------------\n");
  printf("y'=(y/t)(1-y/t) %3.1f<=t<=%3.1f y(1)=1 h=%3.1f\n", a, b, h);
  printf("-----------------------------------------\n");
  printf("    w(i) \t    y(i) \t  error\n");
  for (i = 0; i <= n - 1; i++) {
    t = a + i * h;
    k1 = h * (y[i] / t - pow(y[i] / t, 2));
    k2 = h * ((y[i] + k1 / 2) / (t + h / 2) -
              pow((y[i] + k1 / 2) / (t + h / 2), 2));
    k3 = h * ((y[i] + k2 / 2) / (t + h / 2) -
              pow((y[i] + k2 / 2) / (t + h / 2), 2));
    k4 = h * ((y[i] + k3) / (t + h) - pow((y[i] + k3) / (t + h), 2));
    y[i + 1] = y[i] + (k1 + 2 * k2 + 2 * k3 + k4) / 6;
    true = (t + h) / (1 + log(t + h));
    error = fabs(y[i + 1] - true);
    printf("w(%3.1f)=%f\ty(%3.1f)=%f\t%f\n", t + h, y[i + 1], t + h, true,
           error);
  }
  getch();
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1030 <clrscr@plt>
lea    0xeb0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xec5(%rip),%rdi
lea    -0x5c(%rbp),%rsi
lea    -0x60(%rbp),%rdx
lea    -0xc(%rbp),%rcx
mov    $0x0,%al
call   1050 <scanf@plt>
movss  0xe57(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
lea    0xe8f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x58(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xe91(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
lea    0xe58(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xea5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     15ef <main+0x48f>
movss  -0x5c(%rbp),%xmm1
cvtsi2ssl -0x8(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
divss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
divss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd94(%rip),%xmm1
call   1080 <pow@plt>
movsd  -0xb0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xa8(%rbp),%xmm0
ff
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
movss  -0x44(%rbp),%xmm1
movss  0xd23(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  0xd09(%rip),%xmm3
divss  %xmm3,%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
movss  -0x44(%rbp),%xmm1
movss  0xcda(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  0xcc0(%rip),%xmm3
divss  %xmm3,%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcc8(%rip),%xmm1
call   1080 <pow@plt>
movsd  -0xa0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x98(%rbp),%xmm0
ff
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
movss  -0x48(%rbp),%xmm1
movss  0xc57(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  0xc3d(%rip),%xmm3
divss  %xmm3,%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
movss  -0x48(%rbp),%xmm1
movss  0xc0e(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  0xbf4(%rip),%xmm3
divss  %xmm3,%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbfc(%rip),%xmm1
call   1080 <pow@plt>
movsd  -0x90(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x88(%rbp),%xmm0
ff
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
addss  -0x58(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
addss  -0x58(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb76(%rip),%xmm1
call   1080 <pow@plt>
movsd  -0x80(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x78(%rbp),%xmm0
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
movss  -0x44(%rbp),%xmm1
movss  -0x48(%rbp),%xmm2
addss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  -0x4c(%rbp),%xmm1
addss  %xmm1,%xmm1
addss  %xmm2,%xmm1
addss  -0x50(%rbp),%xmm1
movss  0xaf9(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x40(%rbp,%rax,4)
movss  -0x54(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <log@plt>
movaps %xmm0,%xmm2
movsd  -0x70(%rbp),%xmm0
movsd  0xac9(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x40(%rbp,%rax,4),%xmm0
subss  -0x64(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xa8a(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x40(%rbp,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x54(%rbp),%xmm2
addss  -0x58(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x64(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  -0x68(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
lea    0xafa(%rip),%rdi
mov    $0x5,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1220 <main+0xc0>
mov    $0x0,%al
call   1060 <getch@plt>
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x28,%rsp
xor    %eax,%eax
call   1030 <clrscr@plt>
lea    0xf10(%rip),%rdi
call   1040 <puts@plt>
lea    0xeaf(%rip),%rdi
lea    0x8(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0xc(%rsp),%rcx
xor    %eax,%eax
call   1060 <scanf@plt>
movss  0x10(%rsp),%xmm1
subss  0x8(%rsp),%xmm1
cvtsi2ssl 0xc(%rsp),%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,(%rsp)
lea    0xeee(%rip),%rbx
mov    %rbx,%rdi
call   1040 <puts@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  (%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xe54(%rip),%rdi
movsd  %xmm2,0x18(%rsp)
mov    $0x3,%al
call   1050 <printf@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
lea    0xed0(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    13ac <main+0x24c>
movss  0xde7(%rip),%xmm0
mulss  (%rsp),%xmm0
movss  %xmm0,0x14(%rsp)
movss  0xdd8(%rip),%xmm0
movss  %xmm0,0x4(%rsp)
xor    %ebx,%ebx
lea    0xe2e(%rip),%r14
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
movss  (%rsp),%xmm5
mulss  %xmm5,%xmm0
addss  0x8(%rsp),%xmm0
movss  0x4(%rsp),%xmm2
movaps %xmm2,%xmm1
movaps %xmm2,%xmm4
divss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
movaps %xmm1,%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm1
movsd  0x18(%rsp),%xmm6
mulsd  %xmm6,%xmm1
cvtsd2ss %xmm1,%xmm1
movaps %xmm1,%xmm2
movss  0xd71(%rip),%xmm8
mulss  %xmm8,%xmm2
addss  %xmm4,%xmm2
movaps %xmm4,%xmm7
movss  0x14(%rsp),%xmm3
addss  %xmm0,%xmm3
divss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
movaps %xmm2,%xmm4
mulsd  %xmm2,%xmm4
subsd  %xmm4,%xmm2
mulsd  %xmm6,%xmm2
cvtsd2ss %xmm2,%xmm2
movaps %xmm2,%xmm4
mulss  %xmm8,%xmm4
addss  %xmm7,%xmm4
divss  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
movaps %xmm3,%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm6,%xmm3
cvtsd2ss %xmm3,%xmm3
movaps %xmm7,%xmm4
addss  %xmm3,%xmm4
addss  %xmm5,%xmm0
divss  %xmm0,%xmm4
cvtss2sd %xmm4,%xmm4
movaps %xmm4,%xmm5
mulsd  %xmm4,%xmm5
subsd  %xmm5,%xmm4
mulsd  %xmm6,%xmm4
cvtsd2ss %xmm4,%xmm4
addss  %xmm2,%xmm2
addss  %xmm1,%xmm2
addss  %xmm3,%xmm3
addss  %xmm2,%xmm3
addss  %xmm4,%xmm3
divss  0xcdc(%rip),%xmm3
addss  %xmm3,%xmm7
movss  %xmm7,0x4(%rsp)
add    $0x1,%rbx
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
call   1080 <log@plt>
addsd  0xcbf(%rip),%xmm0
movsd  0x20(%rsp),%xmm5
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  0x4(%rsp),%xmm1
movaps %xmm1,%xmm2
subss  %xmm0,%xmm2
andps  0xca6(%rip),%xmm2
cvtss2sd %xmm1,%xmm1
xorps  %xmm3,%xmm3
cvtss2sd %xmm0,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
mov    %r14,%rdi
movapd %xmm5,%xmm0
movapd %xmm5,%xmm2
mov    $0x5,%al
call   1050 <printf@plt>
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1240 <main+0xe0>
xor    %eax,%eax
call   1070 <getch@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
@.str.1 = [9 x i8] c"%f,%f,%d\00"
@.str.3 = [48 x i8] c"y'=(y/t)(1-y/t) %3.1f<=t<=%3.1f y(1)=1 h=%3.1f\0A\00"
@.str.5 = [28 x i8] c"w(%3.1f)=%f\09y(%3.1f)=%f\09%f\0A\00"
@str = [34 x i8] c"Please input limits and sections.\00"
@str.7 = [42 x i8] c"-----------------------------------------\00"
@str.8 = [28 x i8] c" w(i) \09 y(i) \09 error\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca float
%3 = alloca float
%4 = bitcast i32* %1 to i8*
%5 = bitcast float* %2 to i8*
%6 = bitcast float* %3 to i8*
%7 = tail call i32 (...) @clrscr()
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str, i64 0, i64 0))
%9 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0), float* %2, float* %3, i32* %1)
%10 = load float, float* %3
%11 = load float, float* %2
%12 = fsub float %10, %11
%13 = load i32, i32* %1
%14 = sitofp i32 %13 to float
%15 = fdiv float %12, %14
%16 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.7, i64 0, i64 0))
%17 = load float, float* %2
%18 = fpext float %17 to double
%19 = load float, float* %3
%20 = fpext float %19 to double
%21 = fpext float %15 to double
%22 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.3, i64 0, i64 0), double %18, double %20, double %21)
%23 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.7, i64 0, i64 0))
%24 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.8, i64 0, i64 0))
%25 = load i32, i32* %1
%26 = icmp sgt i32 %25, 0
br i1 %26, label %27, label %87
27: ; preds = %0
%28 = fmul float %15, 5.000000e-01
br label %29
29: ; preds = %27, %29
%30 = phi float [ 1.000000e+00, %27 ], [ %71, %29 ]
%31 = phi i64 [ 0, %27 ], [ %72, %29 ]
%32 = load float, float* %2
%33 = trunc i64 %31 to i32
%34 = sitofp i32 %33 to float
%35 = call float @llvm.fmuladd.f32(float %34, float %15, float %32)
%36 = fdiv float %30, %35
%37 = fpext float %36 to double
%38 = fmul double %37, %37
%39 = fsub double %37, %38
%40 = fmul double %39, %21
%41 = fptrunc double %40 to float
%42 = fmul float %41, 5.000000e-01
%43 = fadd float %30, %42
%44 = fadd float %28, %35
%45 = fdiv float %43, %44
%46 = fpext float %45 to double
%47 = fmul double %46, %46
%48 = fsub double %46, %47
%49 = fmul double %48, %21
%50 = fptrunc double %49 to float
%51 = fmul float %50, 5.000000e-01
%52 = fadd float %30, %51
%53 = fdiv float %52, %44
%54 = fpext float %53 to double
%55 = fmul double %54, %54
%56 = fsub double %54, %55
%57 = fmul double %56, %21
%58 = fptrunc double %57 to float
%59 = fadd float %30, %58
%60 = fadd float %15, %35
%61 = fdiv float %59, %60
%62 = fpext float %61 to double
%63 = fmul double %62, %62
%64 = fsub double %62, %63
%65 = fmul double %64, %21
%66 = fptrunc double %65 to float
%67 = call float @llvm.fmuladd.f32(float %50, float 2.000000e+00, float %41)
%68 = call float @llvm.fmuladd.f32(float %58, float 2.000000e+00, float %67)
%69 = fadd float %68, %66
%70 = fdiv float %69, 6.000000e+00
%71 = fadd float %30, %70
%72 = add nuw nsw i64 %31, 1
%73 = fpext float %60 to double
%74 = call double @log(double %73)
%75 = fadd double %74, 1.000000e+00
%76 = fdiv double %73, %75
%77 = fptrunc double %76 to float
%78 = fsub float %71, %77
%79 = call float @llvm.fabs.f32(float %78)
%80 = fpext float %71 to double
%81 = fpext float %77 to double
%82 = fpext float %79 to double
%83 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), double %73, double %80, double %73, double %81, double %82)
%84 = load i32, i32* %1
%85 = sext i32 %84 to i64
%86 = icmp slt i64 %72, %85
br i1 %86, label %29, label %87
87: ; preds = %29, %0
%88 = call i32 (...) @getch()
ret i32 0
}