#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*/ nicelin(double, double, int, double *, int *);
int /*<<< orphan*/ nicelog(double, double, int, double *, int *);
void getscale(double llimit, double ulimit, int max, char lineflag,
              char logflag, double *retvals, int *nret) {
  int i, nrt;
  double df;
  nrt = max + 1;
  df = (ulimit - llimit) / (float)max;
  for (i = 0; i < nrt - 1; i++)
    retvals[i] = llimit + (df * i);
  retvals[nrt - 1] = ulimit;
  if (logflag) {
    nicelog(llimit, ulimit, max, retvals, &nrt);
  }
  if (lineflag && !logflag) {
    nicelin(llimit, ulimit, max, retvals, &nrt);
  }
  *nret = nrt;
}


x86 assembly (clang, -O0):
<getscale>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %dl,%al
mov    %sil,%dl
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
mov    %dl,-0x15(%rbp)
mov    %al,-0x16(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
movsd  -0x10(%rbp),%xmm0
subsd  -0x8(%rbp),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11b7 <getscale+0x97>
movsd  -0x8(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1174 <getscale+0x54>
movsd  -0x10(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpb   $0x0,-0x16(%rbp)
je     11f2 <getscale+0xd2>
movsd  -0x8(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
lea    -0x30(%rbp),%rdx
call   1030 <nicelog@plt>
movsbl -0x15(%rbp),%eax
cmp    $0x0,%eax
je     1223 <getscale+0x103>
cmpb   $0x0,-0x16(%rbp)
jne    1223 <getscale+0x103>
movsd  -0x8(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
lea    -0x30(%rbp),%rdx
call   1040 <nicelin@plt>
mov    -0x30(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getscale>:
push   %r14
push   %rbx
push   %rax
mov    %r8,%r14
lea    0x1(%rdi),%eax
mov    %eax,0x4(%rsp)
test   %edi,%edi
jle    128d <getscale+0x16d>
movapd %xmm1,%xmm2
subsd  %xmm0,%xmm2
cvtsi2ss %edi,%xmm3
cvtss2sd %xmm3,%xmm3
divsd  %xmm3,%xmm2
mov    %edi,%r8d
cmp    $0x4,%edi
jae    1159 <getscale+0x39>
xor    %eax,%eax
jmp    1270 <getscale+0x150>
mov    %r8d,%eax
and    $0xfffffffc,%eax
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
lea    -0x4(%rax),%rbx
mov    %rbx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rbx,%rbx
je     12c9 <getscale+0x1a9>
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
movdqa 0xe6a(%rip),%xmm6
xor    %ebx,%ebx
movdqa 0xe6f(%rip),%xmm8
movdqa 0xe76(%rip),%xmm9
movdqa 0xe7d(%rip),%xmm10
movdqa 0xe84(%rip),%xmm11
nopl   0x0(%rax)
movdqa %xmm6,%xmm5
cvtdq2pd %xmm6,%xmm7
paddd  %xmm8,%xmm5
cvtdq2pd %xmm5,%xmm5
mulpd  %xmm3,%xmm7
addpd  %xmm4,%xmm7
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm7,(%rcx,%rbx,8)
movupd %xmm5,0x10(%rcx,%rbx,8)
movdqa %xmm6,%xmm5
paddd  %xmm9,%xmm5
movdqa %xmm6,%xmm7
cvtdq2pd %xmm5,%xmm5
paddd  %xmm10,%xmm7
cvtdq2pd %xmm7,%xmm7
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
mulpd  %xmm3,%xmm7
addpd  %xmm4,%xmm7
movupd %xmm5,0x20(%rcx,%rbx,8)
movupd %xmm7,0x30(%rcx,%rbx,8)
add    $0x8,%rbx
paddd  %xmm11,%xmm6
add    $0xfffffffffffffffe,%r10
jne    11c0 <getscale+0xa0>
test   $0x1,%r9b
je     1262 <getscale+0x142>
cvtdq2pd %xmm6,%xmm5
paddd  0xdcd(%rip),%xmm6
cvtdq2pd %xmm6,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
mulpd  %xmm3,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,(%rcx,%rbx,8)
movupd %xmm6,0x10(%rcx,%rbx,8)
cmp    %r8,%rax
je     128d <getscale+0x16d>
nopw   0x0(%rax,%rax,1)
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r8
jne    1270 <getscale+0x150>
movslq %edi,%rax
movsd  %xmm1,(%rcx,%rax,8)
test   %dl,%dl
je     12a8 <getscale+0x188>
lea    0x4(%rsp),%rdx
mov    %rcx,%rsi
call   1030 <nicelog@plt>
jmp    12ba <getscale+0x19a>
test   %sil,%sil
je     12ba <getscale+0x19a>
lea    0x4(%rsp),%rdx
mov    %rcx,%rsi
call   1040 <nicelin@plt>
mov    0x4(%rsp),%eax
mov    %eax,(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
movdqa 0xd2f(%rip),%xmm6
xor    %ebx,%ebx
test   $0x1,%r9b
jne    1237 <getscale+0x117>
jmp    1262 <getscale+0x142>

LLVM IR (-O0):
define void @getscale(double %0, double %1, i32 %2, i8 signext %3, i8 signext %4, double* %5, i32* %6) {
%8 = alloca double
%9 = alloca double
%10 = alloca i32
%11 = alloca i8
%12 = alloca i8
%13 = alloca double*
%14 = alloca i32*
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
store double %0, double* %8
store double %1, double* %9
store i32 %2, i32* %10
store i8 %3, i8* %11
store i8 %4, i8* %12
store double* %5, double** %13
store i32* %6, i32** %14
%18 = load i32, i32* %10
%19 = add nsw i32 %18, 1
store i32 %19, i32* %16
%20 = load double, double* %9
%21 = load double, double* %8
%22 = fsub double %20, %21
%23 = load i32, i32* %10
%24 = sitofp i32 %23 to float
%25 = fpext float %24 to double
%26 = fdiv double %22, %25
store double %26, double* %17
store i32 0, i32* %15
br label %27
27: ; preds = %42, %7
%28 = load i32, i32* %15
%29 = load i32, i32* %16
%30 = sub nsw i32 %29, 1
%31 = icmp slt i32 %28, %30
br i1 %31, label %32, label %45
32: ; preds = %27
%33 = load double, double* %8
%34 = load double, double* %17
%35 = load i32, i32* %15
%36 = sitofp i32 %35 to double
%37 = call double @llvm.fmuladd.f64(double %34, double %36, double %33)
%38 = load double*, double** %13
%39 = load i32, i32* %15
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds double, double* %38, i64 %40
store double %37, double* %41
br label %42
42: ; preds = %32
%43 = load i32, i32* %15
%44 = add nsw i32 %43, 1
store i32 %44, i32* %15
br label %27
45: ; preds = %27
%46 = load double, double* %9
%47 = load double*, double** %13
%48 = load i32, i32* %16
%49 = sub nsw i32 %48, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %47, i64 %50
store double %46, double* %51
%52 = load i8, i8* %12
%53 = icmp ne i8 %52, 0
br i1 %53, label %54, label %60
54: ; preds = %45
%55 = load double, double* %8
%56 = load double, double* %9
%57 = load i32, i32* %10
%58 = load double*, double** %13
%59 = call i32 @nicelog(double %55, double %56, i32 %57, double* %58, i32* %16)
br label %60
60: ; preds = %54, %45
%61 = load i8, i8* %11
%62 = sext i8 %61 to i32
%63 = icmp ne i32 %62, 0
br i1 %63, label %64, label %73
64: ; preds = %60
%65 = load i8, i8* %12
%66 = icmp ne i8 %65, 0
br i1 %66, label %73, label %67
67: ; preds = %64
%68 = load double, double* %8
%69 = load double, double* %9
%70 = load i32, i32* %10
%71 = load double*, double** %13
%72 = call i32 @nicelin(double %68, double %69, i32 %70, double* %71, i32* %16)
br label %73
73: ; preds = %67, %64, %60
%74 = load i32, i32* %16
%75 = load i32*, i32** %14
store i32 %74, i32* %75
ret void
}

LLVM IR (-O2):
define void @getscale(double %0, double %1, i32 %2, i8 signext %3, i8 signext %4, double* %5, i32* nocapture writeonly %6) {
%8 = alloca i32
%9 = bitcast i32* %8 to i8*
%10 = add nsw i32 %2, 1
store i32 %10, i32* %8
%11 = fsub double %1, %0
%12 = sitofp i32 %2 to float
%13 = fpext float %12 to double
%14 = fdiv double %11, %13
%15 = icmp sgt i32 %2, 0
br i1 %15, label %16, label %90
16: ; preds = %7
%17 = zext i32 %2 to i64
%18 = icmp ult i32 %2, 4
br i1 %18, label %80, label %19
19: ; preds = %16
%20 = and i64 %17, 4294967292
%21 = insertelement <2 x double> poison, double %14, i64 0
%22 = shufflevector <2 x double> %21, <2 x double> poison, <2 x i32> zeroinitializer
%23 = insertelement <2 x double> poison, double %0, i64 0
%24 = shufflevector <2 x double> %23, <2 x double> poison, <2 x i32> zeroinitializer
%25 = insertelement <2 x double> poison, double %14, i64 0
%26 = shufflevector <2 x double> %25, <2 x double> poison, <2 x i32> zeroinitializer
%27 = insertelement <2 x double> poison, double %0, i64 0
%28 = shufflevector <2 x double> %27, <2 x double> poison, <2 x i32> zeroinitializer
%29 = add nsw i64 %20, -4
%30 = lshr exact i64 %29, 2
%31 = add nuw nsw i64 %30, 1
%32 = and i64 %31, 1
%33 = icmp eq i64 %29, 0
br i1 %33, label %64, label %34
34: ; preds = %19
%35 = and i64 %31, 9223372036854775806
br label %36
36: ; preds = %36, %34
%37 = phi i64 [ 0, %34 ], [ %60, %36 ]
%38 = phi <2 x i32> [ <i32 0, i32 1>, %34 ], [ %61, %36 ]
%39 = phi i64 [ 0, %34 ], [ %62, %36 ]
%40 = add <2 x i32> %38, <i32 2, i32 2>
%41 = sitofp <2 x i32> %38 to <2 x double>
%42 = sitofp <2 x i32> %40 to <2 x double>
%43 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %22, <2 x double> %41, <2 x double> %24)
%44 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %26, <2 x double> %42, <2 x double> %28)
%45 = getelementptr inbounds double, double* %5, i64 %37
%46 = bitcast double* %45 to <2 x double>*
store <2 x double> %43, <2 x double>* %46
%47 = getelementptr inbounds double, double* %45, i64 2
%48 = bitcast double* %47 to <2 x double>*
store <2 x double> %44, <2 x double>* %48
%49 = or i64 %37, 4
%50 = add <2 x i32> %38, <i32 4, i32 4>
%51 = add <2 x i32> %38, <i32 6, i32 6>
%52 = sitofp <2 x i32> %50 to <2 x double>
%53 = sitofp <2 x i32> %51 to <2 x double>
%54 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %22, <2 x double> %52, <2 x double> %24)
%55 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %26, <2 x double> %53, <2 x double> %28)
%56 = getelementptr inbounds double, double* %5, i64 %49
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> %54, <2 x double>* %57
%58 = getelementptr inbounds double, double* %56, i64 2
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> %55, <2 x double>* %59
%60 = add nuw i64 %37, 8
%61 = add <2 x i32> %38, <i32 8, i32 8>
%62 = add i64 %39, 2
%63 = icmp eq i64 %62, %35
br i1 %63, label %64, label %36
64: ; preds = %36, %19
%65 = phi i64 [ 0, %19 ], [ %60, %36 ]
%66 = phi <2 x i32> [ <i32 0, i32 1>, %19 ], [ %61, %36 ]
%67 = icmp eq i64 %32, 0
br i1 %67, label %78, label %68
68: ; preds = %64
%69 = add <2 x i32> %66, <i32 2, i32 2>
%70 = sitofp <2 x i32> %66 to <2 x double>
%71 = sitofp <2 x i32> %69 to <2 x double>
%72 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %22, <2 x double> %70, <2 x double> %24)
%73 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %26, <2 x double> %71, <2 x double> %28)
%74 = getelementptr inbounds double, double* %5, i64 %65
%75 = bitcast double* %74 to <2 x double>*
store <2 x double> %72, <2 x double>* %75
%76 = getelementptr inbounds double, double* %74, i64 2
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %73, <2 x double>* %77
br label %78
78: ; preds = %64, %68
%79 = icmp eq i64 %20, %17
br i1 %79, label %90, label %80
80: ; preds = %16, %78
%81 = phi i64 [ 0, %16 ], [ %20, %78 ]
br label %82
82: ; preds = %80, %82
%83 = phi i64 [ %88, %82 ], [ %81, %80 ]
%84 = trunc i64 %83 to i32
%85 = sitofp i32 %84 to double
%86 = tail call double @llvm.fmuladd.f64(double %14, double %85, double %0)
%87 = getelementptr inbounds double, double* %5, i64 %83
store double %86, double* %87
%88 = add nuw nsw i64 %83, 1
%89 = icmp eq i64 %88, %17
br i1 %89, label %90, label %82
90: ; preds = %82, %78, %7
%91 = sext i32 %2 to i64
%92 = getelementptr inbounds double, double* %5, i64 %91
store double %1, double* %92
%93 = icmp eq i8 %4, 0
br i1 %93, label %96, label %94
94: ; preds = %90
%95 = call i32 @nicelog(double %0, double %1, i32 %2, double* %5, i32* %8)
br label %100
96: ; preds = %90
%97 = icmp eq i8 %3, 0
br i1 %97, label %100, label %98
98: ; preds = %96
%99 = call i32 @nicelin(double %0, double %1, i32 %2, double* %5, i32* %8)
br label %100
100: ; preds = %94, %98, %96
%101 = load i32, i32* %8
store i32 %101, i32* %6
ret void
}