#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;
    } parts;
  } u;
  static const unsigned long long normal_bit = 0x8000000000000000ull;
  u.ld = 0.0L;
  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)
fldz
fstpt  -0x40(%rbp)
fldt   -0x30(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <isnan@plt>
cmp    $0x0,%rax
jne    1157 <nextafterl+0x47>
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <isnan@plt>
cmp    $0x0,%rax
je     1167 <nextafterl+0x57>
fldt   -0x20(%rbp)
fldt   -0x30(%rbp)
faddp  %st,%st(1)
fstpt  -0x10(%rbp)
jmp    12a8 <nextafterl+0x198>
fldt   -0x20(%rbp)
fldt   -0x30(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    118f <nextafterl+0x7f>
jp     118f <nextafterl+0x7f>
jmp    1184 <nextafterl+0x74>
fldt   -0x30(%rbp)
fstpt  -0x10(%rbp)
jmp    12a8 <nextafterl+0x198>
fldt   -0x20(%rbp)
fstpt  -0x40(%rbp)
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    11ed <nextafterl+0xdd>
jp     11ed <nextafterl+0xdd>
jmp    11b1 <nextafterl+0xa1>
movq   $0x1,-0x40(%rbp)
fldt   -0x30(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jbe    11da <nextafterl+0xca>
jmp    11cf <nextafterl+0xbf>
fldt   -0x40(%rbp)
fstpt  -0x4c(%rbp)
jmp    11e2 <nextafterl+0xd2>
fldt   -0x40(%rbp)
fchs
fstpt  -0x4c(%rbp)
fldt   -0x4c(%rbp)
fstpt  -0x10(%rbp)
jmp    12a8 <nextafterl+0x198>
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    124e <nextafterl+0x13e>
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    1249 <nextafterl+0x139>
mov    -0x38(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x38(%rbp)
jmp    127e <nextafterl+0x16e>
movabs $0x7fffffffffffffff,%rax
ff ff 7f
and    -0x40(%rbp),%rax
cmp    $0x0,%rax
jne    1272 <nextafterl+0x162>
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     12a2 <nextafterl+0x192>
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 = bitcast %union.anon* %6 to x86_fp80*
store x86_fp80 0xK00000000000000000000, x86_fp80* %7
%8 = load x86_fp80, x86_fp80* %5
%9 = call i64 @isnan(x86_fp80 %8)
%10 = icmp ne i64 %9, 0
br i1 %10, label %15, label %11
11: ; preds = %2
%12 = load x86_fp80, x86_fp80* %4
%13 = call i64 @isnan(x86_fp80 %12)
%14 = icmp ne i64 %13, 0
br i1 %14, label %15, label %19
15: ; preds = %11, %2
%16 = load x86_fp80, x86_fp80* %4
%17 = load x86_fp80, x86_fp80* %5
%18 = fadd x86_fp80 %16, %17
store x86_fp80 %18, x86_fp80* %3
br label %101
19: ; preds = %11
%20 = load x86_fp80, x86_fp80* %4
%21 = load x86_fp80, x86_fp80* %5
%22 = fcmp oeq x86_fp80 %20, %21
br i1 %22, label %23, label %25
23: ; preds = %19
%24 = load x86_fp80, x86_fp80* %5
store x86_fp80 %24, x86_fp80* %3
br label %101
25: ; preds = %19
%26 = load x86_fp80, x86_fp80* %4
%27 = bitcast %union.anon* %6 to x86_fp80*
store x86_fp80 %26, x86_fp80* %27
%28 = load x86_fp80, x86_fp80* %4
%29 = fcmp oeq x86_fp80 %28, 0xK00000000000000000000
br i1 %29, label %30, label %44
30: ; preds = %25
%31 = bitcast %union.anon* %6 to %struct.anon*
%32 = getelementptr inbounds %struct.anon, %struct.anon* %31, i32 0, i32 0
store i64 1, i64* %32
%33 = load x86_fp80, x86_fp80* %5
%34 = fcmp ogt x86_fp80 %33, 0xK00000000000000000000
br i1 %34, label %35, label %38
35: ; preds = %30
%36 = bitcast %union.anon* %6 to x86_fp80*
%37 = load x86_fp80, x86_fp80* %36
br label %42
38: ; preds = %30
%39 = bitcast %union.anon* %6 to x86_fp80*
%40 = load x86_fp80, x86_fp80* %39
%41 = fneg x86_fp80 %40
br label %42
42: ; preds = %38, %35
%43 = phi x86_fp80 [ %37, %35 ], [ %41, %38 ]
store x86_fp80 %43, x86_fp80* %3
br label %101
44: ; preds = %25
%45 = load x86_fp80, x86_fp80* %4
%46 = fcmp ogt x86_fp80 %45, 0xK00000000000000000000
%47 = zext i1 %46 to i32
%48 = load x86_fp80, x86_fp80* %5
%49 = load x86_fp80, x86_fp80* %4
%50 = fcmp ogt x86_fp80 %48, %49
%51 = zext i1 %50 to i32
%52 = xor i32 %47, %51
%53 = icmp eq i32 %52, 0
br i1 %53, label %54, label %70
54: ; preds = %44
%55 = bitcast %union.anon* %6 to %struct.anon*
%56 = getelementptr inbounds %struct.anon, %struct.anon* %55, i32 0, i32 0
%57 = load i64, i64* %56
%58 = add i64 %57, 1
store i64 %58, i64* %56
%59 = bitcast %union.anon* %6 to %struct.anon*
%60 = getelementptr inbounds %struct.anon, %struct.anon* %59, i32 0, i32 0
%61 = load i64, i64* %60
%62 = and i64 %61, 9223372036854775807
%63 = icmp eq i64 %62, 0
br i1 %63, label %64, label %69
64: ; preds = %54
%65 = bitcast %union.anon* %6 to %struct.anon*
%66 = getelementptr inbounds %struct.anon, %struct.anon* %65, i32 0, i32 1
%67 = load i16, i16* %66
%68 = add i16 %67, 1
store i16 %68, i16* %66
br label %69
69: ; preds = %64, %54
br label %86
70: ; preds = %44
%71 = bitcast %union.anon* %6 to %struct.anon*
%72 = getelementptr inbounds %struct.anon, %struct.anon* %71, i32 0, i32 0
%73 = load i64, i64* %72
%74 = and i64 %73, 9223372036854775807
%75 = icmp eq i64 %74, 0
br i1 %75, label %76, label %81
76: ; preds = %70
%77 = bitcast %union.anon* %6 to %struct.anon*
%78 = getelementptr inbounds %struct.anon, %struct.anon* %77, i32 0, i32 1
%79 = load i16, i16* %78
%80 = add i16 %79, -1
store i16 %80, i16* %78
br label %81
81: ; preds = %76, %70
%82 = bitcast %union.anon* %6 to %struct.anon*
%83 = getelementptr inbounds %struct.anon, %struct.anon* %82, i32 0, i32 0
%84 = load i64, i64* %83
%85 = add i64 %84, -1
store i64 %85, i64* %83
br label %86
86: ; preds = %81, %69
%87 = bitcast %union.anon* %6 to %struct.anon*
%88 = getelementptr inbounds %struct.anon, %struct.anon* %87, i32 0, i32 1
%89 = load i16, i16* %88
%90 = zext i16 %89 to i32
%91 = and i32 %90, 32767
%92 = icmp ne i32 %91, 0
br i1 %92, label %93, label %98
93: ; preds = %86
%94 = bitcast %union.anon* %6 to %struct.anon*
%95 = getelementptr inbounds %struct.anon, %struct.anon* %94, i32 0, i32 0
%96 = load i64, i64* %95
%97 = or i64 %96, -9223372036854775808
store i64 %97, i64* %95
br label %98
98: ; preds = %93, %86
%99 = bitcast %union.anon* %6 to x86_fp80*
%100 = load x86_fp80, x86_fp80* %99
store x86_fp80 %100, x86_fp80* %3
br label %101
101: ; preds = %98, %42, %23, %15
%102 = load x86_fp80, x86_fp80* %3
ret x86_fp80 %102
}

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
}