#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 */
long double sqrtl(long double);
unsigned julia_it(unsigned maxit, long double *x_0, long double *y_0,
                  long double *cx, long double *cy, long double *modulus) {
  unsigned it = 1;
  long double x;
  long double y;
  long double xc;
  long double yc;
  long double x2;
  long double y2;
  x = *x_0;
  y = *y_0;
  xc = *cx;
  yc = *cy;
  x2 = x * x;
  y2 = y * y;
  while ((x2 + y2) < 16 && it++ < maxit) {
    y = 2 * x * y + yc;
    x = x2 - y2 + xc;
    x2 = x * x;
    y2 = y * y;
  }
  if (it >= maxit)
    return 0;
  unsigned n = 2;
  while (n--) {
    y = 2 * x * y + yc;
    x = x2 - y2 + xc;
    x2 = x * x;
    y2 = y * y;
  }
  if (modulus)
    *modulus = sqrtl(x2 + y2);
  return it;
}


x86 assembly (clang, -O0):
<julia_it>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x10(%rbp),%rax
fldt   (%rax)
fstpt  -0x50(%rbp)
mov    -0x18(%rbp),%rax
fldt   (%rax)
fstpt  -0x60(%rbp)
mov    -0x20(%rbp),%rax
fldt   (%rax)
fstpt  -0x70(%rbp)
mov    -0x28(%rbp),%rax
fldt   (%rax)
fstpt  -0x80(%rbp)
fldt   -0x50(%rbp)
fmul   %st,%st(0)
fstpt  -0x90(%rbp)
fldt   -0x60(%rbp)
fmul   %st,%st(0)
fstpt  -0xa0(%rbp)
fldt   -0x90(%rbp)
fldt   -0xa0(%rbp)
faddp  %st,%st(1)
xor    %eax,%eax
flds   0xe77(%rip)
fucomip %st(1),%st
fstp   %st(0)
mov    %al,-0xa5(%rbp)
jbe    11b5 <julia_it+0xa5>
jmp    119e <julia_it+0x8e>
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cmp    -0x8(%rbp),%eax
setb   %al
mov    %al,-0xa5(%rbp)
mov    -0xa5(%rbp),%al
test   $0x1,%al
jne    11c8 <julia_it+0xb8>
jmp    120d <julia_it+0xfd>
fldt   -0x50(%rbp)
fadd   %st,%st(0)
fldt   -0x60(%rbp)
fldt   -0x80(%rbp)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x60(%rbp)
fldt   -0x90(%rbp)
fldt   -0xa0(%rbp)
fsubrp %st,%st(1)
fldt   -0x70(%rbp)
faddp  %st,%st(1)
fstpt  -0x50(%rbp)
fldt   -0x50(%rbp)
fmul   %st,%st(0)
fstpt  -0x90(%rbp)
fldt   -0x60(%rbp)
fmul   %st,%st(0)
fstpt  -0xa0(%rbp)
jmp    1173 <julia_it+0x63>
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jb     1225 <julia_it+0x115>
movl   $0x0,-0x4(%rbp)
jmp    12bd <julia_it+0x1ad>
movl   $0x2,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xa4(%rbp)
cmp    $0x0,%eax
je     128e <julia_it+0x17e>
fldt   -0x50(%rbp)
fadd   %st,%st(0)
fldt   -0x60(%rbp)
fldt   -0x80(%rbp)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x60(%rbp)
fldt   -0x90(%rbp)
fldt   -0xa0(%rbp)
fsubrp %st,%st(1)
fldt   -0x70(%rbp)
faddp  %st,%st(1)
fstpt  -0x50(%rbp)
fldt   -0x50(%rbp)
fmul   %st,%st(0)
fstpt  -0x90(%rbp)
fldt   -0x60(%rbp)
fmul   %st,%st(0)
fstpt  -0xa0(%rbp)
jmp    122f <julia_it+0x11f>
cmpq   $0x0,-0x30(%rbp)
je     12b7 <julia_it+0x1a7>
fldt   -0x90(%rbp)
fldt   -0xa0(%rbp)
faddp  %st,%st(1)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <sqrtl@plt>
mov    -0x30(%rbp),%rax
fstpt  (%rax)
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<julia_it>:
push   %rbp
push   %rbx
sub    $0x28,%rsp
mov    %r9,%rbx
fldt   (%rsi)
fldt   (%rdx)
fldt   (%rcx)
fstpt  0x1c(%rsp)
fld    %st(1)
fmul   %st(2),%st
fld    %st(1)
fmul   %st(2),%st
fld    %st(1)
fadd   %st(1),%st
flds   0xecb(%rip)
fucomi %st(1),%st
fstp   %st(1)
fldt   (%r8)
mov    $0x1,%ebp
jbe    119d <julia_it+0x8d>
cmp    $0x2,%edi
mov    $0x1,%ebp
mov    $0x1,%ecx
cmovae %edi,%ecx
lea    0x1(%rcx),%eax
cs nopw 0x0(%rax,%rax,1)
cmp    %ebp,%ecx
je     11a1 <julia_it+0x91>
fxch   %st(5)
fadd   %st,%st(0)
fmulp  %st,%st(4)
fxch   %st(3)
fadd   %st(4),%st
fxch   %st(2)
fsubp  %st,%st(1)
fldt   0x1c(%rsp)
faddp  %st,%st(1)
fld    %st(0)
fmul   %st(1),%st
fld    %st(2)
fmul   %st(3),%st
fld    %st(1)
fadd   %st(1),%st
add    $0x1,%ebp
fxch   %st(5)
fucomi %st(5),%st
fstp   %st(5)
fxch   %st(2)
fxch   %st(5)
fxch   %st(3)
fxch   %st(4)
fxch   %st(1)
fxch   %st(3)
ja     1160 <julia_it+0x50>
jmp    11a9 <julia_it+0x99>
fstp   %st(1)
jmp    11a5 <julia_it+0x95>
fstp   %st(1)
mov    %eax,%ebp
fldz
fxch   %st(1)
fstp   %st(1)
xor    %eax,%eax
cmp    %edi,%ebp
jae    120c <julia_it+0xfc>
fxch   %st(4)
fadd   %st,%st(0)
fmulp  %st,%st(3)
fxch   %st(2)
fadd   %st(3),%st
fxch   %st(1)
fsubp  %st,%st(2)
fldt   0x1c(%rsp)
fadd   %st,%st(2)
test   %rbx,%rbx
je     11f4 <julia_it+0xe4>
fld    %st(2)
fadd   %st(3),%st
fmul   %st(2),%st
faddp  %st,%st(4)
fxch   %st(3)
fmul   %st,%st(0)
fxch   %st(2)
fmul   %st,%st(0)
fxch   %st(1)
fmul   %st,%st(0)
fsubrp %st,%st(1)
faddp  %st,%st(2)
fxch   %st(1)
fmul   %st,%st(0)
faddp  %st,%st(1)
fstpt  (%rsp)
call   1030 <sqrtl@plt>
fstpt  (%rbx)
jmp    11fc <julia_it+0xec>
fstp   %st(3)
fstp   %st(0)
fstp   %st(0)
fstp   %st(0)
mov    %ebp,%eax
fldz
fldz
fldz
fldz
fldz
fxch   %st(1)
fxch   %st(4)
fstp   %st(0)
fstp   %st(2)
fstp   %st(0)
fstp   %st(1)
fstp   %st(0)
add    $0x28,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define i32 @julia_it(i32 %0, x86_fp80* %1, x86_fp80* %2, x86_fp80* %3, x86_fp80* %4, x86_fp80* %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca x86_fp80*
%10 = alloca x86_fp80*
%11 = alloca x86_fp80*
%12 = alloca x86_fp80*
%13 = alloca x86_fp80*
%14 = alloca i32
%15 = alloca x86_fp80
%16 = alloca x86_fp80
%17 = alloca x86_fp80
%18 = alloca x86_fp80
%19 = alloca x86_fp80
%20 = alloca x86_fp80
%21 = alloca i32
store i32 %0, i32* %8
store x86_fp80* %1, x86_fp80** %9
store x86_fp80* %2, x86_fp80** %10
store x86_fp80* %3, x86_fp80** %11
store x86_fp80* %4, x86_fp80** %12
store x86_fp80* %5, x86_fp80** %13
store i32 1, i32* %14
%22 = load x86_fp80*, x86_fp80** %9
%23 = load x86_fp80, x86_fp80* %22
store x86_fp80 %23, x86_fp80* %15
%24 = load x86_fp80*, x86_fp80** %10
%25 = load x86_fp80, x86_fp80* %24
store x86_fp80 %25, x86_fp80* %16
%26 = load x86_fp80*, x86_fp80** %11
%27 = load x86_fp80, x86_fp80* %26
store x86_fp80 %27, x86_fp80* %17
%28 = load x86_fp80*, x86_fp80** %12
%29 = load x86_fp80, x86_fp80* %28
store x86_fp80 %29, x86_fp80* %18
%30 = load x86_fp80, x86_fp80* %15
%31 = load x86_fp80, x86_fp80* %15
%32 = fmul x86_fp80 %30, %31
store x86_fp80 %32, x86_fp80* %19
%33 = load x86_fp80, x86_fp80* %16
%34 = load x86_fp80, x86_fp80* %16
%35 = fmul x86_fp80 %33, %34
store x86_fp80 %35, x86_fp80* %20
br label %36
36: ; preds = %48, %6
%37 = load x86_fp80, x86_fp80* %19
%38 = load x86_fp80, x86_fp80* %20
%39 = fadd x86_fp80 %37, %38
%40 = fcmp olt x86_fp80 %39, 0xK40038000000000000000
br i1 %40, label %41, label %46
41: ; preds = %36
%42 = load i32, i32* %14
%43 = add i32 %42, 1
store i32 %43, i32* %14
%44 = load i32, i32* %8
%45 = icmp ult i32 %42, %44
br label %46
46: ; preds = %41, %36
%47 = phi i1 [ false, %36 ], [ %45, %41 ]
br i1 %47, label %48, label %65
48: ; preds = %46
%49 = load x86_fp80, x86_fp80* %15
%50 = fmul x86_fp80 0xK40008000000000000000, %49
%51 = load x86_fp80, x86_fp80* %16
%52 = load x86_fp80, x86_fp80* %18
%53 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %50, x86_fp80 %51, x86_fp80 %52)
store x86_fp80 %53, x86_fp80* %16
%54 = load x86_fp80, x86_fp80* %19
%55 = load x86_fp80, x86_fp80* %20
%56 = fsub x86_fp80 %54, %55
%57 = load x86_fp80, x86_fp80* %17
%58 = fadd x86_fp80 %56, %57
store x86_fp80 %58, x86_fp80* %15
%59 = load x86_fp80, x86_fp80* %15
%60 = load x86_fp80, x86_fp80* %15
%61 = fmul x86_fp80 %59, %60
store x86_fp80 %61, x86_fp80* %19
%62 = load x86_fp80, x86_fp80* %16
%63 = load x86_fp80, x86_fp80* %16
%64 = fmul x86_fp80 %62, %63
store x86_fp80 %64, x86_fp80* %20
br label %36
65: ; preds = %46
%66 = load i32, i32* %14
%67 = load i32, i32* %8
%68 = icmp uge i32 %66, %67
br i1 %68, label %69, label %70
69: ; preds = %65
store i32 0, i32* %7
br label %103
70: ; preds = %65
store i32 2, i32* %21
br label %71
71: ; preds = %75, %70
%72 = load i32, i32* %21
%73 = add i32 %72, -1
store i32 %73, i32* %21
%74 = icmp ne i32 %72, 0
br i1 %74, label %75, label %92
75: ; preds = %71
%76 = load x86_fp80, x86_fp80* %15
%77 = fmul x86_fp80 0xK40008000000000000000, %76
%78 = load x86_fp80, x86_fp80* %16
%79 = load x86_fp80, x86_fp80* %18
%80 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %77, x86_fp80 %78, x86_fp80 %79)
store x86_fp80 %80, x86_fp80* %16
%81 = load x86_fp80, x86_fp80* %19
%82 = load x86_fp80, x86_fp80* %20
%83 = fsub x86_fp80 %81, %82
%84 = load x86_fp80, x86_fp80* %17
%85 = fadd x86_fp80 %83, %84
store x86_fp80 %85, x86_fp80* %15
%86 = load x86_fp80, x86_fp80* %15
%87 = load x86_fp80, x86_fp80* %15
%88 = fmul x86_fp80 %86, %87
store x86_fp80 %88, x86_fp80* %19
%89 = load x86_fp80, x86_fp80* %16
%90 = load x86_fp80, x86_fp80* %16
%91 = fmul x86_fp80 %89, %90
store x86_fp80 %91, x86_fp80* %20
br label %71
92: ; preds = %71
%93 = load x86_fp80*, x86_fp80** %13
%94 = icmp ne x86_fp80* %93, null
br i1 %94, label %95, label %101
95: ; preds = %92
%96 = load x86_fp80, x86_fp80* %19
%97 = load x86_fp80, x86_fp80* %20
%98 = fadd x86_fp80 %96, %97
%99 = call x86_fp80 @sqrtl(x86_fp80 %98)
%100 = load x86_fp80*, x86_fp80** %13
store x86_fp80 %99, x86_fp80* %100
br label %101
101: ; preds = %95, %92
%102 = load i32, i32* %14
store i32 %102, i32* %7
br label %103
103: ; preds = %101, %69
%104 = load i32, i32* %7
ret i32 %104
}

LLVM IR (-O2):
define i32 @julia_it(i32 %0, x86_fp80* nocapture %1, x86_fp80* nocapture %2, x86_fp80* nocapture %3, x86_fp80* nocapture %4, x86_fp80* writeonly %5) {
%7 = load x86_fp80, x86_fp80* %1
%8 = load x86_fp80, x86_fp80* %2
%9 = load x86_fp80, x86_fp80* %3
%10 = load x86_fp80, x86_fp80* %4
%11 = fmul x86_fp80 %7, %7
%12 = fmul x86_fp80 %8, %8
%13 = fadd x86_fp80 %11, %12
%14 = fcmp olt x86_fp80 %13, 0xK40038000000000000000
br i1 %14, label %15, label %35
15: ; preds = %6
%16 = call i32 @llvm.umax.i32(i32 %0, i32 1)
%17 = add i32 %16, 1
br label %18
18: ; preds = %15, %26
%19 = phi x86_fp80 [ %32, %26 ], [ %12, %15 ]
%20 = phi x86_fp80 [ %31, %26 ], [ %11, %15 ]
%21 = phi i32 [ %24, %26 ], [ 1, %15 ]
%22 = phi x86_fp80 [ %30, %26 ], [ %7, %15 ]
%23 = phi x86_fp80 [ %28, %26 ], [ %8, %15 ]
%24 = add i32 %21, 1
%25 = icmp eq i32 %21, %16
br i1 %25, label %35, label %26
26: ; preds = %18
%27 = fmul x86_fp80 %22, 0xK40008000000000000000
%28 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %27, x86_fp80 %23, x86_fp80 %10)
%29 = fsub x86_fp80 %20, %19
%30 = fadd x86_fp80 %9, %29
%31 = fmul x86_fp80 %30, %30
%32 = fmul x86_fp80 %28, %28
%33 = fadd x86_fp80 %31, %32
%34 = fcmp olt x86_fp80 %33, 0xK40038000000000000000
br i1 %34, label %18, label %35
35: ; preds = %18, %26, %6
%36 = phi x86_fp80 [ %8, %6 ], [ %23, %18 ], [ %28, %26 ]
%37 = phi x86_fp80 [ %7, %6 ], [ %22, %18 ], [ %30, %26 ]
%38 = phi x86_fp80 [ %11, %6 ], [ %20, %18 ], [ %31, %26 ]
%39 = phi x86_fp80 [ %12, %6 ], [ %19, %18 ], [ %32, %26 ]
%40 = phi i32 [ 1, %6 ], [ %17, %18 ], [ %24, %26 ]
%41 = icmp ult i32 %40, %0
br i1 %41, label %42, label %59
42: ; preds = %35
%43 = fmul x86_fp80 %37, 0xK40008000000000000000
%44 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %43, x86_fp80 %36, x86_fp80 %10)
%45 = fsub x86_fp80 %38, %39
%46 = fadd x86_fp80 %9, %45
%47 = icmp eq x86_fp80* %5, null
br i1 %47, label %59, label %48
48: ; preds = %42
%49 = fmul x86_fp80 %46, 0xK40008000000000000000
%50 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %49, x86_fp80 %44, x86_fp80 %10)
%51 = fmul x86_fp80 %50, %50
%52 = fmul x86_fp80 %46, %46
%53 = fmul x86_fp80 %44, %44
%54 = fsub x86_fp80 %52, %53
%55 = fadd x86_fp80 %9, %54
%56 = fmul x86_fp80 %55, %55
%57 = fadd x86_fp80 %56, %51
%58 = tail call x86_fp80 @sqrtl(x86_fp80 %57)
store x86_fp80 %58, x86_fp80* %5
br label %59
59: ; preds = %42, %48, %35
%60 = phi i32 [ 0, %35 ], [ %40, %48 ], [ %40, %42 ]
ret i32 %60
}