main(argc, argv) int argc;
char **argv;
{
  int i;
  int n, n_min, n_max;
  double x_min, x_max, dx, x;
  double y_min, y_max, dy, y;
  double r_min, r_max, dr, r;
  double a_min, a_mean, a_width, da, a;
  double m_min, m_max, dm, m;
  double pixscale;
  double ran2();
  long sd;
  if (argc != 15) {
    printf("args: x_min x_max y_min y_max r_min r_max a_mean a_width m_min "
           "m_max n_min n_max sd pixscale\n");
    exit(-1);
  }
  sscanf(argv[1], "%lf", &x_min);
  sscanf(argv[2], "%lf", &x_max);
  sscanf(argv[3], "%lf", &y_min);
  sscanf(argv[4], "%lf", &y_max);
  sscanf(argv[5], "%lf", &r_min);
  sscanf(argv[6], "%lf", &r_max);
  sscanf(argv[7], "%lf", &a_mean);
  sscanf(argv[8], "%lf", &a_width);
  sscanf(argv[9], "%lf", &m_min);
  sscanf(argv[10], "%lf", &m_max);
  sscanf(argv[11], "%d", &n_min);
  sscanf(argv[12], "%d", &n_max);
  sscanf(argv[13], "%d", &sd);
  sscanf(argv[14], "%lf", &pixscale);
  sd = -labs(sd);
  n = (int)(n_min + (n_max - n_min) * ran2(&sd));
  dx = x_max - x_min;
  dy = y_max - y_min;
  dr = r_max - r_min;
  da = 2.0 * a_width;
  a_min = a_mean - a_width;
  dm = m_max - m_min;
  printf("#        x          y        mag   pix_rate      angle  sky_rate     "
         "id\n");
  i = 0;
  while (i < n) {
    x = x_min + dx * ran2(&sd);
    y = y_min + dy * ran2(&sd);
    r = r_min + dr * ran2(&sd);
    a = a_min + da * ran2(&sd);
    m = m_min + dm * ran2(&sd);
    printf("%10.2lf %10.2lf %10.2lf %10.2lf %10.2lf %10.2lf %6d\n", x, y, m,
           r / pixscale, a, r, i);
    i++;
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0xf,-0x8(%rbp)
je     118b <main+0x3b>
lea    0xe8e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xecc(%rip),%rsi
lea    -0x28(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
lea    0xeb2(%rip),%rsi
lea    -0x30(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
lea    0xe98(%rip),%rsi
lea    -0x48(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rdi
lea    0xe7e(%rip),%rsi
lea    -0x50(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rdi
lea    0xe64(%rip),%rsi
lea    -0x68(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rdi
lea    0xe4a(%rip),%rsi
lea    -0x70(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rdi
lea    0xe30(%rip),%rsi
lea    -0x90(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rdi
lea    0xe13(%rip),%rsi
lea    -0x98(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%rdi
lea    0xdf6(%rip),%rsi
lea    -0xb0(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%rdi
lea    0xdd9(%rip),%rsi
lea    -0xb8(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x58(%rax),%rdi
lea    0xdc0(%rip),%rsi
lea    -0x1c(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rdi
lea    0xda6(%rip),%rsi
lea    -0x20(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x68(%rax),%rdi
lea    0xd8c(%rip),%rsi
lea    -0xd8(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0x10(%rbp),%rax
mov    0x70(%rax),%rdi
lea    0xd6b(%rip),%rsi
lea    -0xd0(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <labs@plt>
mov    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
mov    %rax,-0xd8(%rbp)
cvtsi2sdl -0x1c(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x20(%rbp),%eax
sub    -0x1c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
lea    -0xd8(%rbp),%rdi
mov    $0x0,%al
call   1040 <ran2@plt>
movsd  -0xe8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x18(%rbp)
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x70(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xc58(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
lea    0xc7e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15ce <main+0x47e>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
lea    -0xd8(%rbp),%rdi
mov    $0x0,%al
call   1040 <ran2@plt>
movsd  -0x138(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x130(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
lea    -0xd8(%rbp),%rdi
mov    $0x0,%al
call   1040 <ran2@plt>
movsd  -0x128(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x120(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
lea    -0xd8(%rbp),%rdi
mov    $0x0,%al
call   1040 <ran2@plt>
movsd  -0x118(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x110(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
lea    -0xd8(%rbp),%rdi
mov    $0x0,%al
call   1040 <ran2@plt>
movsd  -0x108(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x100(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
lea    -0xd8(%rbp),%rdi
mov    $0x0,%al
call   1040 <ran2@plt>
movsd  -0xf8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm3
divsd  -0xd0(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm4
ff
movsd  -0x80(%rbp),%xmm5
mov    -0x14(%rbp),%esi
lea    0xafd(%rip),%rdi
mov    $0x6,%al
call   1050 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13fd <main+0x2ad>
mov    -0x4(%rbp),%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0xc8,%rsp
cmp    $0xf,%edi
jne    14bb <main+0x36b>
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
lea    0xe8c(%rip),%r14
lea    0x50(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x10(%rbx),%rdi
lea    0xc0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x18(%rbx),%rdi
lea    0x48(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x20(%rbx),%rdi
lea    0xb8(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x28(%rbx),%rdi
lea    0x40(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x30(%rbx),%rdi
lea    0xb0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x38(%rbx),%rdi
lea    0xa8(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x40(%rbx),%rdi
lea    0xa0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x48(%rbx),%rdi
lea    0x38(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x50(%rbx),%rdi
lea    0x98(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x58(%rbx),%rdi
lea    0xdb9(%rip),%rbp
lea    0x34(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x60(%rbx),%rdi
lea    0x30(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x68(%rbx),%rdi
lea    0x28(%rsp),%r15
mov    %rbp,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x70(%rbx),%rdi
lea    0x90(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sscanf@plt>
mov    0x28(%rsp),%rax
mov    %rax,%rcx
neg    %rcx
cmovns %rax,%rcx
mov    %rcx,0x28(%rsp)
mov    0x34(%rsp),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x30(%rsp),%ecx
sub    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <ran2@plt>
mulsd  0x10(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
cvttsd2si %xmm0,%r15d
movsd  0xc0(%rsp),%xmm0
subsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0xb8(%rsp),%xmm0
subsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x68(%rsp)
movsd  0xb0(%rsp),%xmm0
subsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0xa8(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x98(%rsp),%xmm0
subsd  0x38(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
lea    0xcda(%rip),%rdi
call   1030 <puts@plt>
test   %r15d,%r15d
jle    14ab <main+0x35b>
movsd  0x20(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
addsd  %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
lea    0x28(%rsp),%rbx
lea    0xc6b(%rip),%r14
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <ran2@plt>
mulsd  0x70(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x88(%rsp)
movsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <ran2@plt>
mulsd  0x68(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <ran2@plt>
mulsd  0x60(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <ran2@plt>
mulsd  0x20(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x80(%rsp)
movsd  0x38(%rsp),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <ran2@plt>
mulsd  0x58(%rsp),%xmm0
movsd  0x78(%rsp),%xmm2
addsd  %xmm0,%xmm2
movsd  0x10(%rsp),%xmm5
movapd %xmm5,%xmm3
divsd  0x90(%rsp),%xmm3
mov    %r14,%rdi
movsd  0x88(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
movsd  0x80(%rsp),%xmm4
mov    %ebp,%esi
mov    $0x6,%al
call   1050 <printf@plt>
add    $0x1,%ebp
cmp    %ebp,%r15d
jne    13a0 <main+0x250>
xor    %eax,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xbc2(%rip),%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>

LLVM IR (-O0):
@.str = [94 x i8] c"args: x_min x_max y_min y_max r_min r_max a_mean a_width m_min m_max n_min n_max sd pixscale\0A\00"
@.str.1 = [4 x i8] c"%lf\00"
@.str.2 = [3 x i8] c"%d\00"
@.str.3 = [73 x i8] c"# x y mag pix_rate angle sky_rate id\0A\00"
@.str.4 = [53 x i8] c"%10.2lf %10.2lf %10.2lf %10.2lf %10.2lf %10.2lf %6d\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca i64
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%33 = load i32, i32* %4
%34 = icmp ne i32 %33, 15
br i1 %34, label %35, label %37
35: ; preds = %2
%36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str, i64 0, i64 0))
unreachable
37: ; preds = %2
%38 = load i8**, i8*** %5
%39 = getelementptr inbounds i8*, i8** %38, i64 1
%40 = load i8*, i8** %39
%41 = call i32 (i8*, i8*, ...) @sscanf(i8* %40, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %10)
%42 = load i8**, i8*** %5
%43 = getelementptr inbounds i8*, i8** %42, i64 2
%44 = load i8*, i8** %43
%45 = call i32 (i8*, i8*, ...) @sscanf(i8* %44, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %11)
%46 = load i8**, i8*** %5
%47 = getelementptr inbounds i8*, i8** %46, i64 3
%48 = load i8*, i8** %47
%49 = call i32 (i8*, i8*, ...) @sscanf(i8* %48, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %14)
%50 = load i8**, i8*** %5
%51 = getelementptr inbounds i8*, i8** %50, i64 4
%52 = load i8*, i8** %51
%53 = call i32 (i8*, i8*, ...) @sscanf(i8* %52, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %15)
%54 = load i8**, i8*** %5
%55 = getelementptr inbounds i8*, i8** %54, i64 5
%56 = load i8*, i8** %55
%57 = call i32 (i8*, i8*, ...) @sscanf(i8* %56, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %18)
%58 = load i8**, i8*** %5
%59 = getelementptr inbounds i8*, i8** %58, i64 6
%60 = load i8*, i8** %59
%61 = call i32 (i8*, i8*, ...) @sscanf(i8* %60, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %19)
%62 = load i8**, i8*** %5
%63 = getelementptr inbounds i8*, i8** %62, i64 7
%64 = load i8*, i8** %63
%65 = call i32 (i8*, i8*, ...) @sscanf(i8* %64, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %23)
%66 = load i8**, i8*** %5
%67 = getelementptr inbounds i8*, i8** %66, i64 8
%68 = load i8*, i8** %67
%69 = call i32 (i8*, i8*, ...) @sscanf(i8* %68, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %24)
%70 = load i8**, i8*** %5
%71 = getelementptr inbounds i8*, i8** %70, i64 9
%72 = load i8*, i8** %71
%73 = call i32 (i8*, i8*, ...) @sscanf(i8* %72, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %27)
%74 = load i8**, i8*** %5
%75 = getelementptr inbounds i8*, i8** %74, i64 10
%76 = load i8*, i8** %75
%77 = call i32 (i8*, i8*, ...) @sscanf(i8* %76, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %28)
%78 = load i8**, i8*** %5
%79 = getelementptr inbounds i8*, i8** %78, i64 11
%80 = load i8*, i8** %79
%81 = call i32 (i8*, i8*, ...) @sscanf(i8* %80, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %8)
%82 = load i8**, i8*** %5
%83 = getelementptr inbounds i8*, i8** %82, i64 12
%84 = load i8*, i8** %83
%85 = call i32 (i8*, i8*, ...) @sscanf(i8* %84, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %9)
%86 = load i8**, i8*** %5
%87 = getelementptr inbounds i8*, i8** %86, i64 13
%88 = load i8*, i8** %87
%89 = call i32 (i8*, i8*, ...) @sscanf(i8* %88, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i64* %32)
%90 = load i8**, i8*** %5
%91 = getelementptr inbounds i8*, i8** %90, i64 14
%92 = load i8*, i8** %91
%93 = call i32 (i8*, i8*, ...) @sscanf(i8* %92, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %31)
%94 = load i64, i64* %32
%95 = call i64 @labs(i64 %94)
%96 = sub nsw i64 0, %95
store i64 %96, i64* %32
%97 = load i32, i32* %8
%98 = sitofp i32 %97 to double
%99 = load i32, i32* %9
%100 = load i32, i32* %8
%101 = sub nsw i32 %99, %100
%102 = sitofp i32 %101 to double
%103 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %32)
%104 = call double @llvm.fmuladd.f64(double %102, double %103, double %98)
%105 = fptosi double %104 to i32
store i32 %105, i32* %7
%106 = load double, double* %11
%107 = load double, double* %10
%108 = fsub double %106, %107
store double %108, double* %12
%109 = load double, double* %15
%110 = load double, double* %14
%111 = fsub double %109, %110
store double %111, double* %16
%112 = load double, double* %19
%113 = load double, double* %18
%114 = fsub double %112, %113
store double %114, double* %20
%115 = load double, double* %24
%116 = fmul double 2.000000e+00, %115
store double %116, double* %25
%117 = load double, double* %23
%118 = load double, double* %24
%119 = fsub double %117, %118
store double %119, double* %22
%120 = load double, double* %28
%121 = load double, double* %27
%122 = fsub double %120, %121
store double %122, double* %29
%123 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %6
br label %124
124: ; preds = %128, %37
%125 = load i32, i32* %6
%126 = load i32, i32* %7
%127 = icmp slt i32 %125, %126
br i1 %127, label %128, label %161
128: ; preds = %124
%129 = load double, double* %10
%130 = load double, double* %12
%131 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %32)
%132 = call double @llvm.fmuladd.f64(double %130, double %131, double %129)
store double %132, double* %13
%133 = load double, double* %14
%134 = load double, double* %16
%135 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %32)
%136 = call double @llvm.fmuladd.f64(double %134, double %135, double %133)
store double %136, double* %17
%137 = load double, double* %18
%138 = load double, double* %20
%139 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %32)
%140 = call double @llvm.fmuladd.f64(double %138, double %139, double %137)
store double %140, double* %21
%141 = load double, double* %22
%142 = load double, double* %25
%143 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %32)
%144 = call double @llvm.fmuladd.f64(double %142, double %143, double %141)
store double %144, double* %26
%145 = load double, double* %27
%146 = load double, double* %29
%147 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %32)
%148 = call double @llvm.fmuladd.f64(double %146, double %147, double %145)
store double %148, double* %30
%149 = load double, double* %13
%150 = load double, double* %17
%151 = load double, double* %30
%152 = load double, double* %21
%153 = load double, double* %31
%154 = fdiv double %152, %153
%155 = load double, double* %26
%156 = load double, double* %21
%157 = load i32, i32* %6
%158 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.4, i64 0, i64 0), double %149, double %150, double %151, double %154, double %155, double %156, i32 %157)
%159 = load i32, i32* %6
%160 = add nsw i32 %159, 1
store i32 %160, i32* %6
br label %124
161: ; preds = %124
%162 = load i32, i32* %3
ret i32 %162
}

LLVM IR (-O2):
@.str.1 = [4 x i8] c"%lf\00"
@.str.2 = [3 x i8] c"%d\00"
@.str.4 = [53 x i8] c"%10.2lf %10.2lf %10.2lf %10.2lf %10.2lf %10.2lf %6d\0A\00"
@str = [72 x i8] c"# x y mag pix_rate angle sky_rate id\00"
@str.5 = [93 x i8] c"args: x_min x_max y_min y_max r_min r_max a_mean a_width m_min m_max n_min n_max sd pixscale\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca i64
%17 = bitcast i32* %3 to i8*
%18 = bitcast i32* %4 to i8*
%19 = bitcast double* %5 to i8*
%20 = bitcast double* %6 to i8*
%21 = bitcast double* %7 to i8*
%22 = bitcast double* %8 to i8*
%23 = bitcast double* %9 to i8*
%24 = bitcast double* %10 to i8*
%25 = bitcast double* %11 to i8*
%26 = bitcast double* %12 to i8*
%27 = bitcast double* %13 to i8*
%28 = bitcast double* %14 to i8*
%29 = bitcast double* %15 to i8*
%30 = bitcast i64* %16 to i8*
%31 = icmp eq i32 %0, 15
br i1 %31, label %34, label %32
32: ; preds = %2
%33 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([93 x i8], [93 x i8]* @str.5, i64 0, i64 0))
tail call void @exit(i32 -1)
unreachable
34: ; preds = %2
%35 = getelementptr inbounds i8*, i8** %1, i64 1
%36 = load i8*, i8** %35
%37 = call i32 (i8*, i8*, ...) @sscanf(i8* %36, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %5)
%38 = getelementptr inbounds i8*, i8** %1, i64 2
%39 = load i8*, i8** %38
%40 = call i32 (i8*, i8*, ...) @sscanf(i8* %39, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %6)
%41 = getelementptr inbounds i8*, i8** %1, i64 3
%42 = load i8*, i8** %41
%43 = call i32 (i8*, i8*, ...) @sscanf(i8* %42, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %7)
%44 = getelementptr inbounds i8*, i8** %1, i64 4
%45 = load i8*, i8** %44
%46 = call i32 (i8*, i8*, ...) @sscanf(i8* %45, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %8)
%47 = getelementptr inbounds i8*, i8** %1, i64 5
%48 = load i8*, i8** %47
%49 = call i32 (i8*, i8*, ...) @sscanf(i8* %48, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %9)
%50 = getelementptr inbounds i8*, i8** %1, i64 6
%51 = load i8*, i8** %50
%52 = call i32 (i8*, i8*, ...) @sscanf(i8* %51, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %10)
%53 = getelementptr inbounds i8*, i8** %1, i64 7
%54 = load i8*, i8** %53
%55 = call i32 (i8*, i8*, ...) @sscanf(i8* %54, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %11)
%56 = getelementptr inbounds i8*, i8** %1, i64 8
%57 = load i8*, i8** %56
%58 = call i32 (i8*, i8*, ...) @sscanf(i8* %57, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %12)
%59 = getelementptr inbounds i8*, i8** %1, i64 9
%60 = load i8*, i8** %59
%61 = call i32 (i8*, i8*, ...) @sscanf(i8* %60, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %13)
%62 = getelementptr inbounds i8*, i8** %1, i64 10
%63 = load i8*, i8** %62
%64 = call i32 (i8*, i8*, ...) @sscanf(i8* %63, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %14)
%65 = getelementptr inbounds i8*, i8** %1, i64 11
%66 = load i8*, i8** %65
%67 = call i32 (i8*, i8*, ...) @sscanf(i8* %66, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %3)
%68 = getelementptr inbounds i8*, i8** %1, i64 12
%69 = load i8*, i8** %68
%70 = call i32 (i8*, i8*, ...) @sscanf(i8* %69, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %4)
%71 = getelementptr inbounds i8*, i8** %1, i64 13
%72 = load i8*, i8** %71
%73 = call i32 (i8*, i8*, ...) @sscanf(i8* %72, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i64* %16)
%74 = getelementptr inbounds i8*, i8** %1, i64 14
%75 = load i8*, i8** %74
%76 = call i32 (i8*, i8*, ...) @sscanf(i8* %75, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %15)
%77 = load i64, i64* %16
%78 = call i64 @llvm.abs.i64(i64 %77, i1 true)
%79 = sub nsw i64 0, %78
store i64 %79, i64* %16
%80 = load i32, i32* %3
%81 = sitofp i32 %80 to double
%82 = load i32, i32* %4
%83 = sub nsw i32 %82, %80
%84 = sitofp i32 %83 to double
%85 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %16)
%86 = call double @llvm.fmuladd.f64(double %84, double %85, double %81)
%87 = fptosi double %86 to i32
%88 = load double, double* %6
%89 = load double, double* %5
%90 = fsub double %88, %89
%91 = load double, double* %8
%92 = load double, double* %7
%93 = fsub double %91, %92
%94 = load double, double* %10
%95 = load double, double* %9
%96 = fsub double %94, %95
%97 = load double, double* %12
%98 = fmul double %97, 2.000000e+00
%99 = load double, double* %11
%100 = fsub double %99, %97
%101 = load double, double* %14
%102 = load double, double* %13
%103 = fsub double %101, %102
%104 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @str, i64 0, i64 0))
%105 = icmp sgt i32 %87, 0
br i1 %105, label %106, label %127
106: ; preds = %34, %106
%107 = phi i32 [ %125, %106 ], [ 0, %34 ]
%108 = load double, double* %5
%109 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %16)
%110 = call double @llvm.fmuladd.f64(double %90, double %109, double %108)
%111 = load double, double* %7
%112 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %16)
%113 = call double @llvm.fmuladd.f64(double %93, double %112, double %111)
%114 = load double, double* %9
%115 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %16)
%116 = call double @llvm.fmuladd.f64(double %96, double %115, double %114)
%117 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %16)
%118 = call double @llvm.fmuladd.f64(double %98, double %117, double %100)
%119 = load double, double* %13
%120 = call double (i64*, ...) bitcast (double (...)* @ran2 to double (i64*, ...)*)(i64* %16)
%121 = call double @llvm.fmuladd.f64(double %103, double %120, double %119)
%122 = load double, double* %15
%123 = fdiv double %116, %122
%124 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.4, i64 0, i64 0), double %110, double %113, double %121, double %123, double %118, double %116, i32 %107)
%125 = add nuw nsw i32 %107, 1
%126 = icmp eq i32 %125, %87
br i1 %126, label %127, label %106
127: ; preds = %106, %34
ret i32 0
}