#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 */
unsigned int gnulliver();
unsigned long gnulliver64(unsigned long input) {
  static unsigned endian, init = 1;
  char tmpch;
  union {
    unsigned long u;
    char ch[8];
  } bytes;
  if (init) {
    endian = gnulliver();
    init = 0;
  }
  bytes.u = input;
  if (endian != 0) {
    if (endian == (1 | 2 | 4 | 8)) {
      tmpch = bytes.ch[0];
      bytes.ch[0] = bytes.ch[7];
      bytes.ch[7] = tmpch;
      tmpch = bytes.ch[1];
      bytes.ch[1] = bytes.ch[6];
      bytes.ch[6] = tmpch;
      tmpch = bytes.ch[2];
      bytes.ch[2] = bytes.ch[5];
      bytes.ch[5] = tmpch;
      tmpch = bytes.ch[3];
      bytes.ch[3] = bytes.ch[4];
      bytes.ch[4] = tmpch;
    } else {
      tmpch = bytes.ch[0];
      bytes.ch[0] = bytes.ch[6];
      bytes.ch[6] = tmpch;
      tmpch = bytes.ch[1];
      bytes.ch[1] = bytes.ch[7];
      bytes.ch[7] = tmpch;
      tmpch = bytes.ch[2];
      bytes.ch[2] = bytes.ch[4];
      bytes.ch[4] = tmpch;
      tmpch = bytes.ch[3];
      bytes.ch[3] = bytes.ch[5];
      bytes.ch[5] = tmpch;
    }
  }
  return (bytes.u);
}


x86 assembly (clang, -O0):
<gnulliver64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
cmpl   $0x0,0x2f05(%rip)
je     1140 <gnulliver64+0x30>
mov    $0x0,%al
call   1030 <gnulliver@plt>
mov    %eax,0x2efa(%rip)
movl   $0x0,0x2ee8(%rip)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpl   $0x0,0x2ee1(%rip)
je     11fc <gnulliver64+0xec>
cmpl   $0xf,0x2ed4(%rip)
jne    11af <gnulliver64+0x9f>
mov    -0x18(%rbp),%al
mov    %al,-0x9(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x18(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x17(%rbp),%al
mov    %al,-0x9(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x17(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x12(%rbp)
mov    -0x16(%rbp),%al
mov    %al,-0x9(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x16(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x15(%rbp),%al
mov    %al,-0x9(%rbp)
mov    -0x14(%rbp),%al
mov    %al,-0x15(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x14(%rbp)
jmp    11f7 <gnulliver64+0xe7>
mov    -0x18(%rbp),%al
mov    %al,-0x9(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x18(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x12(%rbp)
mov    -0x17(%rbp),%al
mov    %al,-0x9(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x17(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x16(%rbp),%al
mov    %al,-0x9(%rbp)
mov    -0x14(%rbp),%al
mov    %al,-0x16(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x14(%rbp)
mov    -0x15(%rbp),%al
mov    %al,-0x9(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x15(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x13(%rbp)
jmp    11fc <gnulliver64+0xec>
mov    -0x18(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gnulliver64>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rbx
cmpb   $0x1,0x2f11(%rip)
jne    1129 <gnulliver64+0x19>
mov    0x2f05(%rip),%eax
jmp    113d <gnulliver64+0x2d>
xor    %eax,%eax
call   1030 <gnulliver@plt>
mov    %eax,0x2ef6(%rip)
movb   $0x1,0x2ef3(%rip)
mov    %rbx,%r15
shr    $0x8,%r15
mov    %rbx,%rdi
shr    $0x10,%rdi
mov    %rbx,%rsi
shr    $0x18,%rsi
mov    %rbx,%r14
shr    $0x20,%r14
mov    %rbx,%rdx
shr    $0x28,%rdx
mov    %rbx,%r11
shr    $0x30,%r11
mov    %rbx,%rcx
shr    $0x38,%rcx
test   %eax,%eax
je     1191 <gnulliver64+0x81>
cmp    $0xf,%eax
jne    11a5 <gnulliver64+0x95>
mov    %rbx,%rax
mov    %r15,%r10
mov    %rdi,%r9
mov    %rsi,%r8
mov    %r14,%rsi
mov    %rdx,%r14
mov    %r11,%r15
mov    %rcx,%r11
jmp    11b7 <gnulliver64+0xa7>
mov    %rcx,%rax
mov    %r11,%r10
mov    %rdx,%r9
mov    %r14,%r8
mov    %rdi,%r14
mov    %rbx,%r11
jmp    11b7 <gnulliver64+0xa7>
mov    %r15,%rax
mov    %rbx,%r10
mov    %rsi,%r9
mov    %rdi,%r8
mov    %rdx,%rsi
mov    %rcx,%r15
shl    $0x38,%rax
movzbl %r10b,%ecx
shl    $0x30,%rcx
or     %rax,%rcx
movzbl %r9b,%eax
shl    $0x28,%rax
or     %rcx,%rax
movzbl %r8b,%ecx
shl    $0x20,%rcx
or     %rax,%rcx
shl    $0x18,%esi
or     %rcx,%rsi
movzbl %r14b,%eax
shl    $0x10,%rax
or     %rsi,%rax
shl    $0x8,%r15d
movzwl %r15w,%ecx
or     %rax,%rcx
movzbl %r11b,%eax
or     %rcx,%rax
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
%union.anon = type { i64 }
@gnulliver64.endian = internal global i32 0
@gnulliver64.init = internal global i32 1
define i64 @gnulliver64(i64 %0) {
%2 = alloca i64
%3 = alloca i8
%4 = alloca %union.anon
store i64 %0, i64* %2
%5 = load i32, i32* @gnulliver64.init
%6 = icmp ne i32 %5, 0
br i1 %6, label %7, label %9
7: ; preds = %1
%8 = call i32 (...) @gnulliver()
store i32 %8, i32* @gnulliver64.endian
store i32 0, i32* @gnulliver64.init
br label %9
9: ; preds = %7, %1
%10 = load i64, i64* %2
%11 = bitcast %union.anon* %4 to i64*
store i64 %10, i64* %11
%12 = load i32, i32* @gnulliver64.endian
%13 = icmp ne i32 %12, 0
br i1 %13, label %14, label %108
14: ; preds = %9
%15 = load i32, i32* @gnulliver64.endian
%16 = icmp eq i32 %15, 15
br i1 %16, label %17, label %62
17: ; preds = %14
%18 = bitcast %union.anon* %4 to [8 x i8]*
%19 = getelementptr inbounds [8 x i8], [8 x i8]* %18, i64 0, i64 0
%20 = load i8, i8* %19
store i8 %20, i8* %3
%21 = bitcast %union.anon* %4 to [8 x i8]*
%22 = getelementptr inbounds [8 x i8], [8 x i8]* %21, i64 0, i64 7
%23 = load i8, i8* %22
%24 = bitcast %union.anon* %4 to [8 x i8]*
%25 = getelementptr inbounds [8 x i8], [8 x i8]* %24, i64 0, i64 0
store i8 %23, i8* %25
%26 = load i8, i8* %3
%27 = bitcast %union.anon* %4 to [8 x i8]*
%28 = getelementptr inbounds [8 x i8], [8 x i8]* %27, i64 0, i64 7
store i8 %26, i8* %28
%29 = bitcast %union.anon* %4 to [8 x i8]*
%30 = getelementptr inbounds [8 x i8], [8 x i8]* %29, i64 0, i64 1
%31 = load i8, i8* %30
store i8 %31, i8* %3
%32 = bitcast %union.anon* %4 to [8 x i8]*
%33 = getelementptr inbounds [8 x i8], [8 x i8]* %32, i64 0, i64 6
%34 = load i8, i8* %33
%35 = bitcast %union.anon* %4 to [8 x i8]*
%36 = getelementptr inbounds [8 x i8], [8 x i8]* %35, i64 0, i64 1
store i8 %34, i8* %36
%37 = load i8, i8* %3
%38 = bitcast %union.anon* %4 to [8 x i8]*
%39 = getelementptr inbounds [8 x i8], [8 x i8]* %38, i64 0, i64 6
store i8 %37, i8* %39
%40 = bitcast %union.anon* %4 to [8 x i8]*
%41 = getelementptr inbounds [8 x i8], [8 x i8]* %40, i64 0, i64 2
%42 = load i8, i8* %41
store i8 %42, i8* %3
%43 = bitcast %union.anon* %4 to [8 x i8]*
%44 = getelementptr inbounds [8 x i8], [8 x i8]* %43, i64 0, i64 5
%45 = load i8, i8* %44
%46 = bitcast %union.anon* %4 to [8 x i8]*
%47 = getelementptr inbounds [8 x i8], [8 x i8]* %46, i64 0, i64 2
store i8 %45, i8* %47
%48 = load i8, i8* %3
%49 = bitcast %union.anon* %4 to [8 x i8]*
%50 = getelementptr inbounds [8 x i8], [8 x i8]* %49, i64 0, i64 5
store i8 %48, i8* %50
%51 = bitcast %union.anon* %4 to [8 x i8]*
%52 = getelementptr inbounds [8 x i8], [8 x i8]* %51, i64 0, i64 3
%53 = load i8, i8* %52
store i8 %53, i8* %3
%54 = bitcast %union.anon* %4 to [8 x i8]*
%55 = getelementptr inbounds [8 x i8], [8 x i8]* %54, i64 0, i64 4
%56 = load i8, i8* %55
%57 = bitcast %union.anon* %4 to [8 x i8]*
%58 = getelementptr inbounds [8 x i8], [8 x i8]* %57, i64 0, i64 3
store i8 %56, i8* %58
%59 = load i8, i8* %3
%60 = bitcast %union.anon* %4 to [8 x i8]*
%61 = getelementptr inbounds [8 x i8], [8 x i8]* %60, i64 0, i64 4
store i8 %59, i8* %61
br label %107
62: ; preds = %14
%63 = bitcast %union.anon* %4 to [8 x i8]*
%64 = getelementptr inbounds [8 x i8], [8 x i8]* %63, i64 0, i64 0
%65 = load i8, i8* %64
store i8 %65, i8* %3
%66 = bitcast %union.anon* %4 to [8 x i8]*
%67 = getelementptr inbounds [8 x i8], [8 x i8]* %66, i64 0, i64 6
%68 = load i8, i8* %67
%69 = bitcast %union.anon* %4 to [8 x i8]*
%70 = getelementptr inbounds [8 x i8], [8 x i8]* %69, i64 0, i64 0
store i8 %68, i8* %70
%71 = load i8, i8* %3
%72 = bitcast %union.anon* %4 to [8 x i8]*
%73 = getelementptr inbounds [8 x i8], [8 x i8]* %72, i64 0, i64 6
store i8 %71, i8* %73
%74 = bitcast %union.anon* %4 to [8 x i8]*
%75 = getelementptr inbounds [8 x i8], [8 x i8]* %74, i64 0, i64 1
%76 = load i8, i8* %75
store i8 %76, i8* %3
%77 = bitcast %union.anon* %4 to [8 x i8]*
%78 = getelementptr inbounds [8 x i8], [8 x i8]* %77, i64 0, i64 7
%79 = load i8, i8* %78
%80 = bitcast %union.anon* %4 to [8 x i8]*
%81 = getelementptr inbounds [8 x i8], [8 x i8]* %80, i64 0, i64 1
store i8 %79, i8* %81
%82 = load i8, i8* %3
%83 = bitcast %union.anon* %4 to [8 x i8]*
%84 = getelementptr inbounds [8 x i8], [8 x i8]* %83, i64 0, i64 7
store i8 %82, i8* %84
%85 = bitcast %union.anon* %4 to [8 x i8]*
%86 = getelementptr inbounds [8 x i8], [8 x i8]* %85, i64 0, i64 2
%87 = load i8, i8* %86
store i8 %87, i8* %3
%88 = bitcast %union.anon* %4 to [8 x i8]*
%89 = getelementptr inbounds [8 x i8], [8 x i8]* %88, i64 0, i64 4
%90 = load i8, i8* %89
%91 = bitcast %union.anon* %4 to [8 x i8]*
%92 = getelementptr inbounds [8 x i8], [8 x i8]* %91, i64 0, i64 2
store i8 %90, i8* %92
%93 = load i8, i8* %3
%94 = bitcast %union.anon* %4 to [8 x i8]*
%95 = getelementptr inbounds [8 x i8], [8 x i8]* %94, i64 0, i64 4
store i8 %93, i8* %95
%96 = bitcast %union.anon* %4 to [8 x i8]*
%97 = getelementptr inbounds [8 x i8], [8 x i8]* %96, i64 0, i64 3
%98 = load i8, i8* %97
store i8 %98, i8* %3
%99 = bitcast %union.anon* %4 to [8 x i8]*
%100 = getelementptr inbounds [8 x i8], [8 x i8]* %99, i64 0, i64 5
%101 = load i8, i8* %100
%102 = bitcast %union.anon* %4 to [8 x i8]*
%103 = getelementptr inbounds [8 x i8], [8 x i8]* %102, i64 0, i64 3
store i8 %101, i8* %103
%104 = load i8, i8* %3
%105 = bitcast %union.anon* %4 to [8 x i8]*
%106 = getelementptr inbounds [8 x i8], [8 x i8]* %105, i64 0, i64 5
store i8 %104, i8* %106
br label %107
107: ; preds = %62, %17
br label %108
108: ; preds = %107, %9
%109 = bitcast %union.anon* %4 to i64*
%110 = load i64, i64* %109
ret i64 %110
}

LLVM IR (-O2):
@gnulliver64.endian = internal unnamed_addr global i32 0
@gnulliver64.init = internal unnamed_addr global i1 false
define i64 @gnulliver64(i64 %0) {
%2 = load i1, i1* @gnulliver64.init
br i1 %2, label %3, label %5
3: ; preds = %1
%4 = load i32, i32* @gnulliver64.endian
br label %7
5: ; preds = %1
%6 = tail call i32 (...) @gnulliver()
store i32 %6, i32* @gnulliver64.endian
store i1 true, i1* @gnulliver64.init
br label %7
7: ; preds = %3, %5
%8 = phi i32 [ %4, %3 ], [ %6, %5 ]
%9 = lshr i64 %0, 8
%10 = lshr i64 %0, 16
%11 = lshr i64 %0, 24
%12 = lshr i64 %0, 32
%13 = lshr i64 %0, 40
%14 = lshr i64 %0, 48
%15 = lshr i64 %0, 56
switch i32 %8, label %17 [
i32 0, label %18
i32 15, label %16
]
16: ; preds = %7
br label %18
17: ; preds = %7
br label %18
18: ; preds = %7, %16, %17
%19 = phi i64 [ %0, %16 ], [ %9, %17 ], [ %15, %7 ]
%20 = phi i64 [ %9, %16 ], [ %0, %17 ], [ %14, %7 ]
%21 = phi i64 [ %10, %16 ], [ %11, %17 ], [ %13, %7 ]
%22 = phi i64 [ %11, %16 ], [ %10, %17 ], [ %12, %7 ]
%23 = phi i64 [ %12, %16 ], [ %13, %17 ], [ %11, %7 ]
%24 = phi i64 [ %13, %16 ], [ %12, %17 ], [ %10, %7 ]
%25 = phi i64 [ %14, %16 ], [ %15, %17 ], [ %9, %7 ]
%26 = phi i64 [ %15, %16 ], [ %14, %17 ], [ %0, %7 ]
%27 = shl i64 %19, 56
%28 = shl i64 %20, 48
%29 = and i64 %28, 71776119061217280
%30 = or i64 %29, %27
%31 = shl i64 %21, 40
%32 = and i64 %31, 280375465082880
%33 = or i64 %30, %32
%34 = shl i64 %22, 32
%35 = and i64 %34, 1095216660480
%36 = or i64 %33, %35
%37 = shl nuw i64 %23, 24
%38 = and i64 %37, 4278190080
%39 = or i64 %36, %38
%40 = shl nuw i64 %24, 16
%41 = and i64 %40, 16711680
%42 = shl nuw i64 %25, 8
%43 = and i64 %42, 65280
%44 = or i64 %39, %41
%45 = and i64 %26, 255
%46 = or i64 %44, %43
%47 = or i64 %46, %45
ret i64 %47
}