#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 */
scalar_t__ isnan(long double);
long double nextafterl(long double x, long double y) {
  union {
    long double ld;
    struct {
      unsigned long long mantissa;
      unsigned short expn;
      unsigned short pad;
    } __attribute__((packed)) parts;
  } u;
  static const unsigned long long normal_bit = 0x8000000000000000ull;
  if (isnan(y) || isnan(x))
    return x + y;
  if (x == y)
    return y;
  u.ld = x;
  if (x == 0.0L) {
    u.parts.mantissa = 1ull;
    return y > 0.0L ? u.ld : -u.ld;
  }
  if (((x > 0.0L) ^ (y > x)) == 0) {
    u.parts.mantissa++;
    if ((u.parts.mantissa & ~normal_bit) == 0ull)
      u.parts.expn++;
  } else {
    if ((u.parts.mantissa & ~normal_bit) == 0ull)
      u.parts.expn--;
    u.parts.mantissa--;
  }
  if (u.parts.expn & 0x7fff)
    u.parts.mantissa |= normal_bit;
  return u.ld;
}


x86 assembly (clang, -O0):
<nextafterl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
fldt   0x20(%rbp)
fldt   0x10(%rbp)
fstpt  -0x20(%rbp)
fstpt  -0x30(%rbp)
fldt   -0x30(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <isnan@plt>
cmp    $0x0,%rax
jne    1152 <nextafterl+0x42>
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <isnan@plt>
cmp    $0x0,%rax
je     1162 <nextafterl+0x52>
fldt   -0x20(%rbp)
fldt   -0x30(%rbp)
faddp  %st,%st(1)
fstpt  -0x10(%rbp)
jmp    12a3 <nextafterl+0x193>
fldt   -0x20(%rbp)
fldt   -0x30(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    118a <nextafterl+0x7a>
jp     118a <nextafterl+0x7a>
jmp    117f <nextafterl+0x6f>
fldt   -0x30(%rbp)
fstpt  -0x10(%rbp)
jmp    12a3 <nextafterl+0x193>
fldt   -0x20(%rbp)
fstpt  -0x40(%rbp)
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    11e8 <nextafterl+0xd8>
jp     11e8 <nextafterl+0xd8>
jmp    11ac <nextafterl+0x9c>
movq   $0x1,-0x40(%rbp)
fldt   -0x30(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jbe    11d5 <nextafterl+0xc5>
jmp    11ca <nextafterl+0xba>
fldt   -0x40(%rbp)
fstpt  -0x4c(%rbp)
jmp    11dd <nextafterl+0xcd>
fldt   -0x40(%rbp)
fchs
fstpt  -0x4c(%rbp)
fldt   -0x4c(%rbp)
fstpt  -0x10(%rbp)
jmp    12a3 <nextafterl+0x193>
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
seta   %al
movzbl %al,%eax
fldt   -0x30(%rbp)
fucomip %st(1),%st
fstp   %st(0)
seta   %cl
and    $0x1,%cl
movzbl %cl,%ecx
xor    %ecx,%eax
cmp    $0x0,%eax
jne    1249 <nextafterl+0x139>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
movabs $0x7fffffffffffffff,%rax
ff ff 7f
and    -0x40(%rbp),%rax
cmp    $0x0,%rax
jne    1244 <nextafterl+0x134>
mov    -0x38(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x38(%rbp)
jmp    1279 <nextafterl+0x169>
movabs $0x7fffffffffffffff,%rax
ff ff 7f
and    -0x40(%rbp),%rax
cmp    $0x0,%rax
jne    126d <nextafterl+0x15d>
mov    -0x38(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
movzwl -0x38(%rbp),%eax
and    $0x7fff,%eax
cmp    $0x0,%eax
je     129d <nextafterl+0x18d>
movabs $0x8000000000000000,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
fldt   -0x40(%rbp)
fstpt  -0x10(%rbp)
fldt   -0x10(%rbp)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nextafterl>:
sub    $0x78,%rsp
fldt   0x90(%rsp)
fldt   0x80(%rsp)
fstpt  0x14(%rsp)
fld    %st(0)
fstpt  0x54(%rsp)
fstpt  (%rsp)
call   1030 <isnan@plt>
test   %rax,%rax
jne    114a <nextafterl+0x3a>
fldt   0x14(%rsp)
fstpt  (%rsp)
call   1030 <isnan@plt>
test   %rax,%rax
je     1159 <nextafterl+0x49>
fldt   0x14(%rsp)
fldt   0x54(%rsp)
faddp  %st,%st(1)
add    $0x78,%rsp
ret
fldt   0x14(%rsp)
fldt   0x54(%rsp)
fxch   %st(1)
fucomip %st(1),%st
jne    116e <nextafterl+0x5e>
jp     116e <nextafterl+0x5e>
add    $0x78,%rsp
ret
fldz
fldt   0x14(%rsp)
fucomip %st(1),%st
jne    11ab <nextafterl+0x9b>
jp     11ab <nextafterl+0x9b>
fldt   0x14(%rsp)
fstpt  0x60(%rsp)
mov    0x68(%rsp),%eax
mov    %ax,0x28(%rsp)
movq   $0x1,0x20(%rsp)
fldt   0x20(%rsp)
fxch   %st(2)
fucomip %st(1),%st
fstp   %st(0)
fld    %st(0)
fchs
fcmovnbe %st(1),%st
fstp   %st(1)
add    $0x78,%rsp
ret
movabs $0x7fffffffffffffff,%rax
ff ff 7f
fldt   0x14(%rsp)
fld    %st(0)
fstpt  0x40(%rsp)
fucomi %st(1),%st
fstp   %st(1)
setbe  %dil
mov    0x48(%rsp),%esi
mov    0x40(%rsp),%rdx
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
seta   %cl
cmp    %cl,%dil
je     11ec <nextafterl+0xdc>
add    $0x1,%rdx
test   %rax,%rdx
jne    1200 <nextafterl+0xf0>
add    $0x1,%esi
jmp    1200 <nextafterl+0xf0>
lea    0x0(,%rdx,2),%rcx
test   %rcx,%rcx
jne    11fc <nextafterl+0xec>
add    $0xffffffff,%esi
add    $0xffffffffffffffff,%rdx
add    $0x1,%rax
or     %rdx,%rax
test   $0x7fff,%esi
mov    %si,0x38(%rsp)
cmove  %rdx,%rax
mov    %rax,0x30(%rsp)
fldt   0x30(%rsp)
add    $0x78,%rsp
ret

LLVM IR (-O0):
%union.anon = type { x86_fp80 }
%struct.anon = type <{ i64, i16, i16 }>
@nextafterl.normal_bit = internal constant i64 -9223372036854775808
define x86_fp80 @nextafterl(x86_fp80 %0, x86_fp80 %1) {
%3 = alloca x86_fp80
%4 = alloca x86_fp80
%5 = alloca x86_fp80
%6 = alloca %union.anon
store x86_fp80 %0, x86_fp80* %4
store x86_fp80 %1, x86_fp80* %5
%7 = load x86_fp80, x86_fp80* %5
%8 = call i64 @isnan(x86_fp80 %7)
%9 = icmp ne i64 %8, 0
br i1 %9, label %14, label %10
10: ; preds = %2
%11 = load x86_fp80, x86_fp80* %4
%12 = call i64 @isnan(x86_fp80 %11)
%13 = icmp ne i64 %12, 0
br i1 %13, label %14, label %18
14: ; preds = %10, %2
%15 = load x86_fp80, x86_fp80* %4
%16 = load x86_fp80, x86_fp80* %5
%17 = fadd x86_fp80 %15, %16
store x86_fp80 %17, x86_fp80* %3
br label %100
18: ; preds = %10
%19 = load x86_fp80, x86_fp80* %4
%20 = load x86_fp80, x86_fp80* %5
%21 = fcmp oeq x86_fp80 %19, %20
br i1 %21, label %22, label %24
22: ; preds = %18
%23 = load x86_fp80, x86_fp80* %5
store x86_fp80 %23, x86_fp80* %3
br label %100
24: ; preds = %18
%25 = load x86_fp80, x86_fp80* %4
%26 = bitcast %union.anon* %6 to x86_fp80*
store x86_fp80 %25, x86_fp80* %26
%27 = load x86_fp80, x86_fp80* %4
%28 = fcmp oeq x86_fp80 %27, 0xK00000000000000000000
br i1 %28, label %29, label %43
29: ; preds = %24
%30 = bitcast %union.anon* %6 to %struct.anon*
%31 = getelementptr inbounds %struct.anon, %struct.anon* %30, i32 0, i32 0
store i64 1, i64* %31
%32 = load x86_fp80, x86_fp80* %5
%33 = fcmp ogt x86_fp80 %32, 0xK00000000000000000000
br i1 %33, label %34, label %37
34: ; preds = %29
%35 = bitcast %union.anon* %6 to x86_fp80*
%36 = load x86_fp80, x86_fp80* %35
br label %41
37: ; preds = %29
%38 = bitcast %union.anon* %6 to x86_fp80*
%39 = load x86_fp80, x86_fp80* %38
%40 = fneg x86_fp80 %39
br label %41
41: ; preds = %37, %34
%42 = phi x86_fp80 [ %36, %34 ], [ %40, %37 ]
store x86_fp80 %42, x86_fp80* %3
br label %100
43: ; preds = %24
%44 = load x86_fp80, x86_fp80* %4
%45 = fcmp ogt x86_fp80 %44, 0xK00000000000000000000
%46 = zext i1 %45 to i32
%47 = load x86_fp80, x86_fp80* %5
%48 = load x86_fp80, x86_fp80* %4
%49 = fcmp ogt x86_fp80 %47, %48
%50 = zext i1 %49 to i32
%51 = xor i32 %46, %50
%52 = icmp eq i32 %51, 0
br i1 %52, label %53, label %69
53: ; preds = %43
%54 = bitcast %union.anon* %6 to %struct.anon*
%55 = getelementptr inbounds %struct.anon, %struct.anon* %54, i32 0, i32 0
%56 = load i64, i64* %55
%57 = add i64 %56, 1
store i64 %57, i64* %55
%58 = bitcast %union.anon* %6 to %struct.anon*
%59 = getelementptr inbounds %struct.anon, %struct.anon* %58, i32 0, i32 0
%60 = load i64, i64* %59
%61 = and i64 %60, 9223372036854775807
%62 = icmp eq i64 %61, 0
br i1 %62, label %63, label %68
63: ; preds = %53
%64 = bitcast %union.anon* %6 to %struct.anon*
%65 = getelementptr inbounds %struct.anon, %struct.anon* %64, i32 0, i32 1
%66 = load i16, i16* %65
%67 = add i16 %66, 1
store i16 %67, i16* %65
br label %68
68: ; preds = %63, %53
br label %85
69: ; preds = %43
%70 = bitcast %union.anon* %6 to %struct.anon*
%71 = getelementptr inbounds %struct.anon, %struct.anon* %70, i32 0, i32 0
%72 = load i64, i64* %71
%73 = and i64 %72, 9223372036854775807
%74 = icmp eq i64 %73, 0
br i1 %74, label %75, label %80
75: ; preds = %69
%76 = bitcast %union.anon* %6 to %struct.anon*
%77 = getelementptr inbounds %struct.anon, %struct.anon* %76, i32 0, i32 1
%78 = load i16, i16* %77
%79 = add i16 %78, -1
store i16 %79, i16* %77
br label %80
80: ; preds = %75, %69
%81 = bitcast %union.anon* %6 to %struct.anon*
%82 = getelementptr inbounds %struct.anon, %struct.anon* %81, i32 0, i32 0
%83 = load i64, i64* %82
%84 = add i64 %83, -1
store i64 %84, i64* %82
br label %85
85: ; preds = %80, %68
%86 = bitcast %union.anon* %6 to %struct.anon*
%87 = getelementptr inbounds %struct.anon, %struct.anon* %86, i32 0, i32 1
%88 = load i16, i16* %87
%89 = zext i16 %88 to i32
%90 = and i32 %89, 32767
%91 = icmp ne i32 %90, 0
br i1 %91, label %92, label %97
92: ; preds = %85
%93 = bitcast %union.anon* %6 to %struct.anon*
%94 = getelementptr inbounds %struct.anon, %struct.anon* %93, i32 0, i32 0
%95 = load i64, i64* %94
%96 = or i64 %95, -9223372036854775808
store i64 %96, i64* %94
br label %97
97: ; preds = %92, %85
%98 = bitcast %union.anon* %6 to x86_fp80*
%99 = load x86_fp80, x86_fp80* %98
store x86_fp80 %99, x86_fp80* %3
br label %100
100: ; preds = %97, %41, %22, %14
%101 = load x86_fp80, x86_fp80* %3
ret x86_fp80 %101
}

LLVM IR (-O2):
define x86_fp80 @nextafterl(x86_fp80 %0, x86_fp80 %1) {
%3 = tail call i64 @isnan(x86_fp80 %1)
%4 = icmp eq i64 %3, 0
br i1 %4, label %5, label %8
5: ; preds = %2
%6 = tail call i64 @isnan(x86_fp80 %0)
%7 = icmp eq i64 %6, 0
br i1 %7, label %10, label %8
8: ; preds = %5, %2
%9 = fadd x86_fp80 %0, %1
br label %71
10: ; preds = %5
%11 = fcmp oeq x86_fp80 %0, %1
br i1 %11, label %71, label %12
12: ; preds = %10
%13 = fcmp oeq x86_fp80 %0, 0xK00000000000000000000
br i1 %13, label %14, label %22
14: ; preds = %12
%15 = bitcast x86_fp80 %0 to i80
%16 = and i80 %15, -18446744073709551616
%17 = or i80 %16, 1
%18 = bitcast i80 %17 to x86_fp80
%19 = fcmp ogt x86_fp80 %1, 0xK00000000000000000000
%20 = fneg x86_fp80 %18
%21 = select i1 %19, x86_fp80 %18, x86_fp80 %20
br label %71
22: ; preds = %12
%23 = fcmp ule x86_fp80 %0, 0xK00000000000000000000
%24 = fcmp ogt x86_fp80 %1, %0
%25 = xor i1 %23, %24
%26 = bitcast x86_fp80 %0 to i80
br i1 %25, label %27, label %42
27: ; preds = %22
%28 = trunc i80 %26 to i64
%29 = add i64 %28, 1
%30 = zext i64 %29 to i80
%31 = and i80 %26, -18446744073709551616
%32 = or i80 %31, %30
%33 = and i64 %29, 9223372036854775807
%34 = icmp eq i64 %33, 0
br i1 %34, label %35, label %60
35: ; preds = %27
%36 = lshr i80 %26, 64
%37 = trunc i80 %36 to i16
%38 = add i16 %37, 1
%39 = zext i16 %38 to i80
%40 = shl nuw i80 %39, 64
%41 = or i80 %40, %30
br label %60
42: ; preds = %22
%43 = and i80 %26, 9223372036854775807
%44 = icmp eq i80 %43, 0
br i1 %44, label %45, label %53
45: ; preds = %42
%46 = lshr i80 %26, 64
%47 = trunc i80 %46 to i16
%48 = add i16 %47, -1
%49 = zext i16 %48 to i80
%50 = shl nuw i80 %49, 64
%51 = and i80 %26, 18446744073709551615
%52 = or i80 %50, %51
br label %53
53: ; preds = %45, %42
%54 = phi i80 [ %52, %45 ], [ %26, %42 ]
%55 = trunc i80 %54 to i64
%56 = add i64 %55, -1
%57 = zext i64 %56 to i80
%58 = and i80 %54, -18446744073709551616
%59 = or i80 %58, %57
br label %60
60: ; preds = %27, %35, %53
%61 = phi i80 [ %41, %35 ], [ %32, %27 ], [ %59, %53 ]
%62 = and i80 %61, 604444463063240877801472
%63 = icmp eq i80 %62, 0
%64 = trunc i80 %61 to i64
%65 = or i64 %64, -9223372036854775808
%66 = zext i64 %65 to i80
%67 = and i80 %61, -18446744073709551616
%68 = or i80 %67, %66
%69 = select i1 %63, i80 %61, i80 %68
%70 = bitcast i80 %69 to x86_fp80
br label %71
71: ; preds = %10, %60, %14, %8
%72 = phi x86_fp80 [ %9, %8 ], [ %21, %14 ], [ %70, %60 ], [ %1, %10 ]
ret x86_fp80 %72
}